style: format python files with isort and double-quote-string-fixer

tools/test_apps/system/gdb_loadable_elf/app_test.py

@@ -1,12 +1,14 @@
 from __future__ import unicode_literals
-from tiny_test_fw import Utility
-import debug_backend
+
 import os
-import pexpect
-import serial
 import threading
 import time
+
+import debug_backend
+import pexpect
+import serial
 import ttfw_idf
+from tiny_test_fw import Utility
 
 
 class SerialThread(object):
@@ -33,12 +35,12 @@ class SerialThread(object):
             Utility.console_log('The pyserial thread is still alive', 'O')
 
 
-@ttfw_idf.idf_custom_test(env_tag="test_jtag_arm", group="test-apps")
+@ttfw_idf.idf_custom_test(env_tag='test_jtag_arm', group='test-apps')
 def test_app_loadable_elf(env, extra_data):
 
     rel_project_path = os.path.join('tools', 'test_apps', 'system', 'gdb_loadable_elf')
     app_files = ['gdb_loadable_elf.elf']
-    app = ttfw_idf.LoadableElfTestApp(rel_project_path, app_files, target="esp32")
+    app = ttfw_idf.LoadableElfTestApp(rel_project_path, app_files, target='esp32')
     idf_path = app.get_sdk_path()
     proj_path = os.path.join(idf_path, rel_project_path)
     elf_path = os.path.join(app.binary_path, 'gdb_loadable_elf.elf')

tools/test_apps/system/memprot/app_test.py

@@ -3,7 +3,6 @@
 import ttfw_idf
 from tiny_test_fw import Utility
 
-
 mem_test = [
     ['IRAM0_SRAM', 'WRX'],
     ['IRAM0_RTCFAST', 'WRX'],
@@ -15,24 +14,24 @@ mem_test = [
 ]
 
 
-@ttfw_idf.idf_custom_test(env_tag="Example_GENERIC", target="esp32s2", group="test-apps")
+@ttfw_idf.idf_custom_test(env_tag='Example_GENERIC', target='esp32s2', group='test-apps')
 def test_memprot(env, extra_data):
 
-    dut = env.get_dut("memprot", "tools/test_apps/system/memprot")
+    dut = env.get_dut('memprot', 'tools/test_apps/system/memprot')
     dut.start_app()
 
     for i in mem_test:
         if 'R' in i[1]:
-            dut.expect(i[0] + " read low: OK")
-            dut.expect(i[0] + " read high: OK")
+            dut.expect(i[0] + ' read low: OK')
+            dut.expect(i[0] + ' read high: OK')
         if 'W' in i[1]:
-            dut.expect(i[0] + " write low: OK")
-            dut.expect(i[0] + " write high: OK")
+            dut.expect(i[0] + ' write low: OK')
+            dut.expect(i[0] + ' write high: OK')
         if 'X' in i[1]:
-            dut.expect(i[0] + " exec low: OK")
-            dut.expect(i[0] + " exec high: OK")
+            dut.expect(i[0] + ' exec low: OK')
+            dut.expect(i[0] + ' exec high: OK')
 
-    Utility.console_log("Memprot test done")
+    Utility.console_log('Memprot test done')
 
 
 if __name__ == '__main__':

tools/test_apps/system/monitor_ide_integration/app_test.py

@@ -1,12 +1,14 @@
 from __future__ import unicode_literals
-from SimpleWebSocketServer import SimpleWebSocketServer, WebSocket
-from tiny_test_fw import Utility
+
 import glob
 import json
 import os
 import re
 import threading
+
 import ttfw_idf
+from SimpleWebSocketServer import SimpleWebSocketServer, WebSocket
+from tiny_test_fw import Utility
 
 
 class IDEWSProtocol(WebSocket):

tools/test_apps/system/panic/app_test.py

@@ -1,295 +1,295 @@
 #!/usr/bin/env python
 import sys
+
 import panic_tests as test
 from test_panic_util.test_panic_util import panic_test, run_all
 
 
 # test_task_wdt
-
 @panic_test(target=['ESP32', 'ESP32S2'])
 def test_panic_task_wdt(env, _extra_data):
-    test.task_wdt_inner(env, "panic")
+    test.task_wdt_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_task_wdt_uart_elf_crc(env, _extra_data):
-    test.task_wdt_inner(env, "coredump_uart_elf_crc")
+    test.task_wdt_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_task_wdt_uart_bin_crc(env, _extra_data):
-    test.task_wdt_inner(env, "coredump_uart_bin_crc")
+    test.task_wdt_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_task_wdt_flash_elf_sha(env, _extra_data):
-    test.task_wdt_inner(env, "coredump_flash_elf_sha")
+    test.task_wdt_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_task_wdt_flash_bin_crc(env, _extra_data):
-    test.task_wdt_inner(env, "coredump_flash_bin_crc")
+    test.task_wdt_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_task_wdt(env, _extra_data):
-    test.task_wdt_inner(env, "gdbstub")
+    test.task_wdt_inner(env, 'gdbstub')
 
 
 # test_int_wdt
 
 @panic_test()
 def test_panic_int_wdt(env, _extra_data):
-    test.int_wdt_inner(env, "panic")
+    test.int_wdt_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_int_wdt_uart_elf_crc(env, _extra_data):
-    test.int_wdt_inner(env, "coredump_uart_elf_crc")
+    test.int_wdt_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_int_wdt_uart_bin_crc(env, _extra_data):
-    test.int_wdt_inner(env, "coredump_uart_bin_crc")
+    test.int_wdt_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_int_wdt_flash_elf_sha(env, _extra_data):
-    test.int_wdt_inner(env, "coredump_flash_elf_sha")
+    test.int_wdt_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_int_wdt_flash_bin_crc(env, _extra_data):
-    test.int_wdt_inner(env, "coredump_flash_bin_crc")
+    test.int_wdt_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_int_wdt(env, _extra_data):
-    test.int_wdt_inner(env, "gdbstub")
+    test.int_wdt_inner(env, 'gdbstub')
 
 
 # test_int_wdt_cache_disabled
 
 @panic_test()
 def test_panic_int_wdt_cache_disabled(env, _extra_data):
-    test.int_wdt_cache_disabled_inner(env, "panic")
+    test.int_wdt_cache_disabled_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_int_wdt_cache_disabled_uart_elf_crc(env, _extra_data):
-    test.int_wdt_cache_disabled_inner(env, "coredump_uart_elf_crc")
+    test.int_wdt_cache_disabled_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_int_wdt_cache_disabled_uart_bin_crc(env, _extra_data):
-    test.int_wdt_cache_disabled_inner(env, "coredump_uart_bin_crc")
+    test.int_wdt_cache_disabled_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_int_wdt_cache_disabled_flash_elf_sha(env, _extra_data):
-    test.int_wdt_cache_disabled_inner(env, "coredump_flash_elf_sha")
+    test.int_wdt_cache_disabled_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_int_wdt_cache_disabled_flash_bin_crc(env, _extra_data):
-    test.int_wdt_cache_disabled_inner(env, "coredump_flash_bin_crc")
+    test.int_wdt_cache_disabled_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_int_wdt_cache_disabled(env, _extra_data):
-    test.int_wdt_cache_disabled_inner(env, "gdbstub")
+    test.int_wdt_cache_disabled_inner(env, 'gdbstub')
 
 
 # test_cache_error
 
 @panic_test()
 def test_panic_cache_error(env, _extra_data):
-    test.cache_error_inner(env, "panic")
+    test.cache_error_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_cache_error_uart_elf_crc(env, _extra_data):
-    test.cache_error_inner(env, "coredump_uart_elf_crc")
+    test.cache_error_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_cache_error_uart_bin_crc(env, _extra_data):
-    test.cache_error_inner(env, "coredump_uart_bin_crc")
+    test.cache_error_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_cache_error_flash_elf_sha(env, _extra_data):
-    test.cache_error_inner(env, "coredump_flash_elf_sha")
+    test.cache_error_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_cache_error_flash_bin_crc(env, _extra_data):
-    test.cache_error_inner(env, "coredump_flash_bin_crc")
+    test.cache_error_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_cache_error(env, _extra_data):
-    test.cache_error_inner(env, "gdbstub")
+    test.cache_error_inner(env, 'gdbstub')
 
 
 # test_stack_overflow
 
 @panic_test(target=['ESP32', 'ESP32S2'])
 def test_panic_stack_overflow(env, _extra_data):
-    test.stack_overflow_inner(env, "panic")
+    test.stack_overflow_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_stack_overflow_uart_elf_crc(env, _extra_data):
-    test.stack_overflow_inner(env, "coredump_uart_elf_crc")
+    test.stack_overflow_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_stack_overflow_uart_bin_crc(env, _extra_data):
-    test.stack_overflow_inner(env, "coredump_uart_bin_crc")
+    test.stack_overflow_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_stack_overflow_flash_elf_sha(env, _extra_data):
-    test.stack_overflow_inner(env, "coredump_flash_elf_sha")
+    test.stack_overflow_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_stack_overflow_flash_bin_crc(env, _extra_data):
-    test.stack_overflow_inner(env, "coredump_flash_bin_crc")
+    test.stack_overflow_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_stack_overflow(env, _extra_data):
-    test.stack_overflow_inner(env, "gdbstub")
+    test.stack_overflow_inner(env, 'gdbstub')
 
 
 # test_instr_fetch_prohibited
 
 @panic_test(target=['ESP32', 'ESP32S2'])
 def test_panic_instr_fetch_prohibited(env, _extra_data):
-    test.instr_fetch_prohibited_inner(env, "panic")
+    test.instr_fetch_prohibited_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_instr_fetch_prohibited_uart_elf_crc(env, _extra_data):
-    test.instr_fetch_prohibited_inner(env, "coredump_uart_elf_crc")
+    test.instr_fetch_prohibited_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_instr_fetch_prohibited_uart_bin_crc(env, _extra_data):
-    test.instr_fetch_prohibited_inner(env, "coredump_uart_bin_crc")
+    test.instr_fetch_prohibited_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_instr_fetch_prohibited_flash_elf_sha(env, _extra_data):
-    test.instr_fetch_prohibited_inner(env, "coredump_flash_elf_sha")
+    test.instr_fetch_prohibited_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_instr_fetch_prohibited_flash_bin_crc(env, _extra_data):
-    test.instr_fetch_prohibited_inner(env, "coredump_flash_bin_crc")
+    test.instr_fetch_prohibited_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_instr_fetch_prohibited(env, _extra_data):
-    test.instr_fetch_prohibited_inner(env, "gdbstub")
+    test.instr_fetch_prohibited_inner(env, 'gdbstub')
 
 
 # test_illegal_instruction
 
 @panic_test(target=['ESP32', 'ESP32S2'])
 def test_panic_illegal_instruction(env, _extra_data):
-    test.illegal_instruction_inner(env, "panic")
+    test.illegal_instruction_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_illegal_instruction_uart_elf_crc(env, _extra_data):
-    test.illegal_instruction_inner(env, "coredump_uart_elf_crc")
+    test.illegal_instruction_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_illegal_instruction_uart_bin_crc(env, _extra_data):
-    test.illegal_instruction_inner(env, "coredump_uart_bin_crc")
+    test.illegal_instruction_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_illegal_instruction_flash_elf_sha(env, _extra_data):
-    test.illegal_instruction_inner(env, "coredump_flash_elf_sha")
+    test.illegal_instruction_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_illegal_instruction_flash_bin_crc(env, _extra_data):
-    test.illegal_instruction_inner(env, "coredump_flash_bin_crc")
+    test.illegal_instruction_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_illegal_instruction(env, _extra_data):
-    test.illegal_instruction_inner(env, "gdbstub")
+    test.illegal_instruction_inner(env, 'gdbstub')
 
 
 # test_storeprohibited
 
 @panic_test(target=['ESP32', 'ESP32S2'])
 def test_panic_storeprohibited(env, _extra_data):
-    test.storeprohibited_inner(env, "panic")
+    test.storeprohibited_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_storeprohibited_uart_elf_crc(env, _extra_data):
-    test.storeprohibited_inner(env, "coredump_uart_elf_crc")
+    test.storeprohibited_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_storeprohibited_uart_bin_crc(env, _extra_data):
-    test.storeprohibited_inner(env, "coredump_uart_bin_crc")
+    test.storeprohibited_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_storeprohibited_flash_elf_sha(env, _extra_data):
-    test.storeprohibited_inner(env, "coredump_flash_elf_sha")
+    test.storeprohibited_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_storeprohibited_flash_bin_crc(env, _extra_data):
-    test.storeprohibited_inner(env, "coredump_flash_bin_crc")
+    test.storeprohibited_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_storeprohibited(env, _extra_data):
-    test.storeprohibited_inner(env, "gdbstub")
+    test.storeprohibited_inner(env, 'gdbstub')
 
 
 # test_abort
 
 @panic_test(target=['ESP32', 'ESP32S2'])
 def test_panic_abort(env, _extra_data):
-    test.abort_inner(env, "panic")
+    test.abort_inner(env, 'panic')
 
 
 @panic_test()
 def test_coredump_abort_uart_elf_crc(env, _extra_data):
-    test.abort_inner(env, "coredump_uart_elf_crc")
+    test.abort_inner(env, 'coredump_uart_elf_crc')
 
 
 @panic_test()
 def test_coredump_abort_uart_bin_crc(env, _extra_data):
-    test.abort_inner(env, "coredump_uart_bin_crc")
+    test.abort_inner(env, 'coredump_uart_bin_crc')
 
 
 @panic_test()
 def test_coredump_abort_flash_elf_sha(env, _extra_data):
-    test.abort_inner(env, "coredump_flash_elf_sha")
+    test.abort_inner(env, 'coredump_flash_elf_sha')
 
 
 @panic_test()
 def test_coredump_abort_flash_bin_crc(env, _extra_data):
-    test.abort_inner(env, "coredump_flash_bin_crc")
+    test.abort_inner(env, 'coredump_flash_bin_crc')
 
 
 @panic_test()
 def test_gdbstub_abort(env, _extra_data):
-    test.abort_inner(env, "gdbstub")
+    test.abort_inner(env, 'gdbstub')
 
 
 if __name__ == '__main__':

tools/test_apps/system/panic/panic_tests.py

@@ -1,15 +1,16 @@
 #!/usr/bin/env python
-from pprint import pformat
 import re
+from pprint import pformat
+
 from test_panic_util.test_panic_util import get_dut
 
 
 def get_default_backtrace(test_name):
     return [
         test_name,
-        "app_main",
-        "main_task",
-        "vPortTaskWrapper"
+        'app_main',
+        'main_task',
+        'vPortTaskWrapper'
     ]
 
 
@@ -17,133 +18,133 @@ def test_common(dut, test_name, expected_backtrace=None):
     if expected_backtrace is None:
         expected_backtrace = get_default_backtrace(dut.test_name)
 
-    if "gdbstub" in test_name:
+    if 'gdbstub' in test_name:
         dut.start_gdb()
         frames = dut.gdb_backtrace()
         if not dut.match_backtrace(frames, expected_backtrace):
-            raise AssertionError("Unexpected backtrace in test {}:\n{}".format(test_name, pformat(frames)))
+            raise AssertionError('Unexpected backtrace in test {}:\n{}'.format(test_name, pformat(frames)))
         return
 
-    if "uart" in test_name:
+    if 'uart' in test_name:
         dut.expect(dut.COREDUMP_UART_END)
 
-    dut.expect("Rebooting...")
+    dut.expect('Rebooting...')
 
-    if "uart" in test_name:
+    if 'uart' in test_name:
         dut.process_coredump_uart()
         # TODO: check backtrace
-    elif "flash" in test_name:
+    elif 'flash' in test_name:
         dut.process_coredump_flash()
         # TODO: check backtrace
-    elif "panic" in test_name:
+    elif 'panic' in test_name:
         # TODO: check backtrace
         pass
 
 
 def task_wdt_inner(env, test_name):
-    with get_dut(env, test_name, "test_task_wdt", qemu_wdt_enable=True) as dut:
-        dut.expect("Task watchdog got triggered. The following tasks did not reset the watchdog in time:")
-        dut.expect("CPU 0: main")
-        dut.expect(re.compile(r"abort\(\) was called at PC [0-9xa-f]+ on core 0"))
-        dut.expect_none("register dump:")
+    with get_dut(env, test_name, 'test_task_wdt', qemu_wdt_enable=True) as dut:
+        dut.expect('Task watchdog got triggered. The following tasks did not reset the watchdog in time:')
+        dut.expect('CPU 0: main')
+        dut.expect(re.compile(r'abort\(\) was called at PC [0-9xa-f]+ on core 0'))
+        dut.expect_none('register dump:')
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name, expected_backtrace=[
             # Backtrace interrupted when abort is called, IDF-842.
             # Task WDT calls abort internally.
-            "panic_abort", "esp_system_abort"
+            'panic_abort', 'esp_system_abort'
         ])
 
 
 def int_wdt_inner(env, test_name):
-    with get_dut(env, test_name, "test_int_wdt", qemu_wdt_enable=True) as dut:
-        dut.expect_gme("Interrupt wdt timeout on CPU0")
+    with get_dut(env, test_name, 'test_int_wdt', qemu_wdt_enable=True) as dut:
+        dut.expect_gme('Interrupt wdt timeout on CPU0')
         dut.expect_reg_dump(0)
         dut.expect_backtrace()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         dut.expect_reg_dump(1)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name)
 
 
 def int_wdt_cache_disabled_inner(env, test_name):
-    with get_dut(env, test_name, "test_int_wdt_cache_disabled", qemu_wdt_enable=True) as dut:
-        dut.expect("Re-enable cpu cache.")
-        dut.expect_gme("Interrupt wdt timeout on CPU0")
+    with get_dut(env, test_name, 'test_int_wdt_cache_disabled', qemu_wdt_enable=True) as dut:
+        dut.expect('Re-enable cpu cache.')
+        dut.expect_gme('Interrupt wdt timeout on CPU0')
         dut.expect_reg_dump(0)
-        dut.expect("Backtrace:")
-        dut.expect_none("Guru Meditation")
+        dut.expect('Backtrace:')
+        dut.expect_none('Guru Meditation')
         dut.expect_reg_dump(1)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name)
 
 
 def cache_error_inner(env, test_name):
-    with get_dut(env, test_name, "test_cache_error") as dut:
-        dut.expect("Re-enable cpu cache.")
-        dut.expect_gme("Cache disabled but cached memory region accessed")
+    with get_dut(env, test_name, 'test_cache_error') as dut:
+        dut.expect('Re-enable cpu cache.')
+        dut.expect_gme('Cache disabled but cached memory region accessed')
         dut.expect_reg_dump(0)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name,
-                    expected_backtrace=["die"] + get_default_backtrace(dut.test_name))
+                    expected_backtrace=['die'] + get_default_backtrace(dut.test_name))
 
 
 def abort_inner(env, test_name):
-    with get_dut(env, test_name, "test_abort") as dut:
-        dut.expect(re.compile(r"abort\(\) was called at PC [0-9xa-f]+ on core 0"))
+    with get_dut(env, test_name, 'test_abort') as dut:
+        dut.expect(re.compile(r'abort\(\) was called at PC [0-9xa-f]+ on core 0'))
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation", "Re-entered core dump")
+        dut.expect_none('Guru Meditation', 'Re-entered core dump')
         test_common(dut, test_name, expected_backtrace=[
             # Backtrace interrupted when abort is called, IDF-842
-            "panic_abort", "esp_system_abort"
+            'panic_abort', 'esp_system_abort'
         ])
 
 
 def storeprohibited_inner(env, test_name):
-    with get_dut(env, test_name, "test_storeprohibited") as dut:
-        dut.expect_gme("StoreProhibited")
+    with get_dut(env, test_name, 'test_storeprohibited') as dut:
+        dut.expect_gme('StoreProhibited')
         dut.expect_reg_dump(0)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name)
 
 
 def stack_overflow_inner(env, test_name):
-    with get_dut(env, test_name, "test_stack_overflow") as dut:
-        dut.expect_gme("Unhandled debug exception")
-        dut.expect("Stack canary watchpoint triggered (main)")
+    with get_dut(env, test_name, 'test_stack_overflow') as dut:
+        dut.expect_gme('Unhandled debug exception')
+        dut.expect('Stack canary watchpoint triggered (main)')
         dut.expect_reg_dump(0)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name)
 
 
 def illegal_instruction_inner(env, test_name):
-    with get_dut(env, test_name, "test_illegal_instruction") as dut:
-        dut.expect_gme("IllegalInstruction")
+    with get_dut(env, test_name, 'test_illegal_instruction') as dut:
+        dut.expect_gme('IllegalInstruction')
         dut.expect_reg_dump(0)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name)
 
 
 def instr_fetch_prohibited_inner(env, test_name):
-    with get_dut(env, test_name, "test_instr_fetch_prohibited") as dut:
-        dut.expect_gme("InstrFetchProhibited")
+    with get_dut(env, test_name, 'test_instr_fetch_prohibited') as dut:
+        dut.expect_gme('InstrFetchProhibited')
         dut.expect_reg_dump(0)
         dut.expect_backtrace()
         dut.expect_elf_sha256()
-        dut.expect_none("Guru Meditation")
+        dut.expect_none('Guru Meditation')
         test_common(dut, test_name,
-                    expected_backtrace=["_init"] + get_default_backtrace(dut.test_name))
+                    expected_backtrace=['_init'] + get_default_backtrace(dut.test_name))

tools/test_apps/system/panic/test_panic_util/test_panic_util.py

@@ -1,17 +1,17 @@
 import logging
 import os
-from pygdbmi.gdbcontroller import GdbController
 import re
 import subprocess
 import sys
-import ttfw_idf
-from tiny_test_fw import Utility, TinyFW, DUT
-from tiny_test_fw.Utility import SearchCases, CaseConfig
 
+import ttfw_idf
+from pygdbmi.gdbcontroller import GdbController
+from tiny_test_fw import DUT, TinyFW, Utility
+from tiny_test_fw.Utility import CaseConfig, SearchCases
 
 # hard-coded to the path one level above - only intended to be used from the panic test app
-TEST_PATH = os.path.relpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."), os.getenv("IDF_PATH"))
-TEST_SUITE = "Panic"
+TEST_PATH = os.path.relpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'), os.getenv('IDF_PATH'))
+TEST_SUITE = 'Panic'
 
 
 def ok(data):
@@ -21,7 +21,7 @@ def ok(data):
 
 def unexpected(data):
     """ Helper function used with dut.expect_any """
-    raise AssertionError("Unexpected: {}".format(data))
+    raise AssertionError('Unexpected: {}'.format(data))
 
 
 class PanicTestApp(ttfw_idf.TestApp):
@@ -33,8 +33,8 @@ class PanicTestMixin(object):
     BOOT_CMD_ADDR = 0x9000
     BOOT_CMD_SIZE = 0x1000
     DEFAULT_EXPECT_TIMEOUT = 10
-    COREDUMP_UART_START = "================= CORE DUMP START ================="
-    COREDUMP_UART_END = "================= CORE DUMP END ================="
+    COREDUMP_UART_START = '================= CORE DUMP START ================='
+    COREDUMP_UART_END = '================= CORE DUMP END ================='
 
     def start_test(self, test_name):
         """ Starts the app and sends it the test name """
@@ -42,24 +42,24 @@ class PanicTestMixin(object):
         # Start the app and verify that it has started up correctly
         self.start_capture_raw_data()
         self.start_app()
-        self.expect("Enter test name: ")
-        Utility.console_log("Setting boot command: " + test_name)
+        self.expect('Enter test name: ')
+        Utility.console_log('Setting boot command: ' + test_name)
         self.write(test_name)
-        self.expect("Got test name: " + test_name)
+        self.expect('Got test name: ' + test_name)
 
     def expect_none(self, *patterns, **timeout_args):
         """ like dut.expect_all, but with an inverse logic """
         found_data = []
-        if "timeout" not in timeout_args:
-            timeout_args["timeout"] = 1
+        if 'timeout' not in timeout_args:
+            timeout_args['timeout'] = 1
 
         def found(data):
-            raise AssertionError("Unexpected: {}".format(data))
+            raise AssertionError('Unexpected: {}'.format(data))
             found_data.append(data)
         try:
             expect_items = [(pattern, found) for pattern in patterns]
             self.expect_any(*expect_items, **timeout_args)
-            raise AssertionError("Unexpected: {}".format(found_data))
+            raise AssertionError('Unexpected: {}'.format(found_data))
         except DUT.ExpectTimeout:
             return True
 
@@ -69,18 +69,18 @@ class PanicTestMixin(object):
 
     def expect_reg_dump(self, core=0):
         """ Expect method for the register dump """
-        self.expect(re.compile(r"Core\s+%d register dump:" % core))
+        self.expect(re.compile(r'Core\s+%d register dump:' % core))
 
     def expect_elf_sha256(self):
         """ Expect method for ELF SHA256 line """
         elf_sha256 = self.app.get_elf_sha256()
         sdkconfig = self.app.get_sdkconfig()
-        elf_sha256_len = int(sdkconfig.get("CONFIG_APP_RETRIEVE_LEN_ELF_SHA", "16"))
-        self.expect("ELF file SHA256: " + elf_sha256[0:elf_sha256_len])
+        elf_sha256_len = int(sdkconfig.get('CONFIG_APP_RETRIEVE_LEN_ELF_SHA', '16'))
+        self.expect('ELF file SHA256: ' + elf_sha256[0:elf_sha256_len])
 
     def expect_backtrace(self):
-        self.expect("Backtrace:")
-        self.expect_none("CORRUPTED")
+        self.expect('Backtrace:')
+        self.expect_none('CORRUPTED')
 
     def __enter__(self):
         self._raw_data = None
@@ -89,8 +89,8 @@ class PanicTestMixin(object):
 
     def __exit__(self, type, value, traceback):
         log_folder = self.app.get_log_folder(TEST_SUITE)
-        with open(os.path.join(log_folder, "log_" + self.test_name + ".txt"), "w") as log_file:
-            Utility.console_log("Writing output of {} to {}".format(self.test_name, log_file.name))
+        with open(os.path.join(log_folder, 'log_' + self.test_name + '.txt'), 'w') as log_file:
+            Utility.console_log('Writing output of {} to {}'.format(self.test_name, log_file.name))
             log_file.write(self.get_raw_data())
         if self.gdb:
             self.gdb.exit()
@@ -103,18 +103,18 @@ class PanicTestMixin(object):
 
     def _call_espcoredump(self, extra_args, coredump_file_name, output_file_name):
         # no "with" here, since we need the file to be open for later inspection by the test case
-        self.coredump_output = open(output_file_name, "w")
-        espcoredump_script = os.path.join(os.environ["IDF_PATH"], "components", "espcoredump", "espcoredump.py")
+        self.coredump_output = open(output_file_name, 'w')
+        espcoredump_script = os.path.join(os.environ['IDF_PATH'], 'components', 'espcoredump', 'espcoredump.py')
         espcoredump_args = [
             sys.executable,
             espcoredump_script,
-            "info_corefile",
-            "--core", coredump_file_name,
+            'info_corefile',
+            '--core', coredump_file_name,
         ]
         espcoredump_args += extra_args
         espcoredump_args.append(self.app.elf_file)
-        Utility.console_log("Running " + " ".join(espcoredump_args))
-        Utility.console_log("espcoredump output is written to " + self.coredump_output.name)
+        Utility.console_log('Running ' + ' '.join(espcoredump_args))
+        Utility.console_log('espcoredump output is written to ' + self.coredump_output.name)
 
         subprocess.check_call(espcoredump_args, stdout=self.coredump_output)
         self.coredump_output.flush()
@@ -127,22 +127,22 @@ class PanicTestMixin(object):
         coredump_start = data.find(self.COREDUMP_UART_START)
         coredump_end = data.find(self.COREDUMP_UART_END)
         coredump_base64 = data[coredump_start + len(self.COREDUMP_UART_START):coredump_end]
-        with open(os.path.join(log_folder, "coredump_data_" + self.test_name + ".b64"), "w") as coredump_file:
-            Utility.console_log("Writing UART base64 core dump to " + coredump_file.name)
+        with open(os.path.join(log_folder, 'coredump_data_' + self.test_name + '.b64'), 'w') as coredump_file:
+            Utility.console_log('Writing UART base64 core dump to ' + coredump_file.name)
             coredump_file.write(coredump_base64)
 
-        output_file_name = os.path.join(log_folder, "coredump_uart_result_" + self.test_name + ".txt")
-        self._call_espcoredump(["--core-format", "b64"], coredump_file.name, output_file_name)
+        output_file_name = os.path.join(log_folder, 'coredump_uart_result_' + self.test_name + '.txt')
+        self._call_espcoredump(['--core-format', 'b64'], coredump_file.name, output_file_name)
 
     def process_coredump_flash(self):
         """ Extract the core dump from flash, run espcoredump on it """
         log_folder = self.app.get_log_folder(TEST_SUITE)
-        coredump_file_name = os.path.join(log_folder, "coredump_data_" + self.test_name + ".bin")
-        Utility.console_log("Writing flash binary core dump to " + coredump_file_name)
-        self.dump_flash(coredump_file_name, partition="coredump")
+        coredump_file_name = os.path.join(log_folder, 'coredump_data_' + self.test_name + '.bin')
+        Utility.console_log('Writing flash binary core dump to ' + coredump_file_name)
+        self.dump_flash(coredump_file_name, partition='coredump')
 
-        output_file_name = os.path.join(log_folder, "coredump_flash_result_" + self.test_name + ".txt")
-        self._call_espcoredump(["--core-format", "raw"], coredump_file_name, output_file_name)
+        output_file_name = os.path.join(log_folder, 'coredump_flash_result_' + self.test_name + '.txt')
+        self._call_espcoredump(['--core-format', 'raw'], coredump_file_name, output_file_name)
 
     def start_gdb(self):
         """
@@ -152,44 +152,44 @@ class PanicTestMixin(object):
         self.stop_receive()
         self._port_close()
 
-        Utility.console_log("Starting GDB...", "orange")
-        self.gdb = GdbController(gdb_path=self.TOOLCHAIN_PREFIX + "gdb")
+        Utility.console_log('Starting GDB...', 'orange')
+        self.gdb = GdbController(gdb_path=self.TOOLCHAIN_PREFIX + 'gdb')
 
         # pygdbmi logs to console by default, make it log to a file instead
         log_folder = self.app.get_log_folder(TEST_SUITE)
-        pygdbmi_log_file_name = os.path.join(log_folder, "pygdbmi_log_" + self.test_name + ".txt")
+        pygdbmi_log_file_name = os.path.join(log_folder, 'pygdbmi_log_' + self.test_name + '.txt')
         pygdbmi_logger = self.gdb.logger
         pygdbmi_logger.setLevel(logging.DEBUG)
         while pygdbmi_logger.hasHandlers():
             pygdbmi_logger.removeHandler(pygdbmi_logger.handlers[0])
         log_handler = logging.FileHandler(pygdbmi_log_file_name)
-        log_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s: %(message)s"))
+        log_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s'))
         pygdbmi_logger.addHandler(log_handler)
 
         # Set up logging for GDB remote protocol
-        gdb_remotelog_file_name = os.path.join(log_folder, "gdb_remote_log_" + self.test_name + ".txt")
-        self.gdb.write("-gdb-set remotelogfile " + gdb_remotelog_file_name)
+        gdb_remotelog_file_name = os.path.join(log_folder, 'gdb_remote_log_' + self.test_name + '.txt')
+        self.gdb.write('-gdb-set remotelogfile ' + gdb_remotelog_file_name)
 
         # Load the ELF file
-        self.gdb.write("-file-exec-and-symbols {}".format(self.app.elf_file))
+        self.gdb.write('-file-exec-and-symbols {}'.format(self.app.elf_file))
 
         # Connect GDB to UART
-        Utility.console_log("Connecting to GDB Stub...", "orange")
-        self.gdb.write("-gdb-set serial baud 115200")
-        responses = self.gdb.write("-target-select remote " + self.get_gdb_remote(), timeout_sec=3)
+        Utility.console_log('Connecting to GDB Stub...', 'orange')
+        self.gdb.write('-gdb-set serial baud 115200')
+        responses = self.gdb.write('-target-select remote ' + self.get_gdb_remote(), timeout_sec=3)
 
         # Make sure we get the 'stopped' notification
         stop_response = self.find_gdb_response('stopped', 'notify', responses)
         if not stop_response:
-            responses = self.gdb.write("-exec-interrupt", timeout_sec=3)
+            responses = self.gdb.write('-exec-interrupt', timeout_sec=3)
             stop_response = self.find_gdb_response('stopped', 'notify', responses)
             assert stop_response
-        frame = stop_response["payload"]["frame"]
-        if "file" not in frame:
-            frame["file"] = "?"
-        if "line" not in frame:
-            frame["line"] = "?"
-        Utility.console_log("Stopped in {func} at {addr} ({file}:{line})".format(**frame), "orange")
+        frame = stop_response['payload']['frame']
+        if 'file' not in frame:
+            frame['file'] = '?'
+        if 'line' not in frame:
+            frame['line'] = '?'
+        Utility.console_log('Stopped in {func} at {addr} ({file}:{line})'.format(**frame), 'orange')
 
         # Drain remaining responses
         self.gdb.get_gdb_response(raise_error_on_timeout=False)
@@ -201,8 +201,8 @@ class PanicTestMixin(object):
         """
         assert self.gdb
 
-        responses = self.gdb.write("-stack-list-frames", timeout_sec=3)
-        return self.find_gdb_response("done", "result", responses)["payload"]["stack"]
+        responses = self.gdb.write('-stack-list-frames', timeout_sec=3)
+        return self.find_gdb_response('done', 'result', responses)['payload']['stack']
 
     @staticmethod
     def match_backtrace(gdb_backtrace, expected_functions_list):
@@ -211,7 +211,7 @@ class PanicTestMixin(object):
         given by gdb_backtrace argument. The latter is in the same format as returned by gdb_backtrace()
         function.
         """
-        return all([frame["func"] == expected_functions_list[i] for i, frame in enumerate(gdb_backtrace)])
+        return all([frame['func'] == expected_functions_list[i] for i, frame in enumerate(gdb_backtrace)])
 
     @staticmethod
     def find_gdb_response(message, response_type, responses):
@@ -220,8 +220,8 @@ class PanicTestMixin(object):
         by message and type. Returned message is a dictionary, refer to pygdbmi docs for the format.
         """
         def match_response(response):
-            return (response["message"] == message and
-                    response["type"] == response_type)
+            return (response['message'] == message and
+                    response['type'] == response_type)
 
         filtered_responses = [r for r in responses if match_response(r)]
         if not filtered_responses:
@@ -252,11 +252,11 @@ def panic_test(**kwargs):
 
     if 'additional_duts' not in kwargs:
         kwargs['additional_duts'] = PANIC_TEST_DUT_DICT
-    return ttfw_idf.idf_custom_test(app=PanicTestApp, env_tag="Example_GENERIC", **kwargs)
+    return ttfw_idf.idf_custom_test(app=PanicTestApp, env_tag='Example_GENERIC', **kwargs)
 
 
 def get_dut(env, app_config_name, test_name, qemu_wdt_enable=False):
-    dut = env.get_dut("panic", TEST_PATH, app_config_name=app_config_name, allow_dut_exception=True)
+    dut = env.get_dut('panic', TEST_PATH, app_config_name=app_config_name, allow_dut_exception=True)
     dut.qemu_wdt_enable = qemu_wdt_enable
     """ Wrapper for getting the DUT and starting the test """
     dut.start_test(test_name)
@@ -270,13 +270,13 @@ def run_all(filename, case_filter=[]):
     """
     TinyFW.set_default_config(env_config_file=None, test_suite_name=TEST_SUITE)
     test_methods = SearchCases.Search.search_test_cases(filename)
-    test_methods = filter(lambda m: not m.case_info["ignore"], test_methods)
+    test_methods = filter(lambda m: not m.case_info['ignore'], test_methods)
     test_cases = CaseConfig.Parser.apply_config(test_methods, None)
     tests_failed = []
     for case in test_cases:
         test_name = case.test_method.__name__
         if case_filter:
-            if case_filter[0].endswith("*"):
+            if case_filter[0].endswith('*'):
                 if not test_name.startswith(case_filter[0][:-1]):
                     continue
             else:
@@ -287,9 +287,9 @@ def run_all(filename, case_filter=[]):
             tests_failed.append(case)
 
     if tests_failed:
-        print("The following tests have failed:")
+        print('The following tests have failed:')
         for case in tests_failed:
-            print(" - " + case.test_method.__name__)
+            print(' - ' + case.test_method.__name__)
         raise SystemExit(1)
 
-    print("Tests pass")
+    print('Tests pass')

tools/test_apps/system/startup/app_test.py

@@ -1,22 +1,23 @@
 #!/usr/bin/env python
 
-import os
 import glob
+import os
+
 import ttfw_idf
 from tiny_test_fw import Utility
 
 
-@ttfw_idf.idf_custom_test(env_tag="Example_GENERIC", group="test-apps")
+@ttfw_idf.idf_custom_test(env_tag='Example_GENERIC', group='test-apps')
 def test_startup(env, extra_data):
-    config_files = glob.glob(os.path.join(os.path.dirname(__file__), "sdkconfig.ci.*"))
-    config_names = [os.path.basename(s).replace("sdkconfig.ci.", "") for s in config_files]
+    config_files = glob.glob(os.path.join(os.path.dirname(__file__), 'sdkconfig.ci.*'))
+    config_names = [os.path.basename(s).replace('sdkconfig.ci.', '') for s in config_files]
     for name in config_names:
-        Utility.console_log("Checking config \"{}\"... ".format(name), end="")
-        dut = env.get_dut("startup", "tools/test_apps/system/startup", app_config_name=name)
+        Utility.console_log("Checking config \"{}\"... ".format(name), end='')
+        dut = env.get_dut('startup', 'tools/test_apps/system/startup', app_config_name=name)
         dut.start_app()
-        dut.expect("app_main running")
+        dut.expect('app_main running')
         env.close_dut(dut.name)
-        Utility.console_log("done")
+        Utility.console_log('done')
 
 
 if __name__ == '__main__':