Complete this pass of pylint changes. (#401)

2 files changed, 151 insertions, 149 deletions

diff --git a/debug/gdbserver.py b/debug/gdbserver.py
index 2e5a18e..e30305d 100755
--- a/debug/gdbserver.py
+++ b/debug/gdbserver.py
@@ -41,7 +41,7 @@ MSTATUS64_SD = 0x8000000000000000
 
 def ihex_line(address, record_type, data):
     assert len(data) < 128
-    line = ":%02X%04X%02X" % (len(data), address, record_type)
+    line = f":{len(data):02X}{address:04X}{record_type:02X}"
     check = len(data)
     check += address % 256
     check += address >> 8
@@ -49,8 +49,8 @@ def ihex_line(address, record_type, data):
     for char in data:
         value = ord(char)
         check += value
-        line += "%02X" % value
-    line += "%02X\n" % ((256-check)%256)
+        line += f"{value:02X}"
+    line += f"{(256 - check) % 256:02X}\n"
     return line
 
 def srec_parse(line):
@@ -66,17 +66,17 @@ def srec_parse(line):
         # Any higher bits were chopped off.
         address = int(line[4:12], 16)
         for i in range(6, count+1):
-            data += "%c" % int(line[2*i:2*i+2], 16)
+            data += f"{int(line[2 * i:2 * i + 2], 16):c}"
         # Ignore the checksum.
         return 3, address, data
     elif typ == b'S7':
         # ignore execution start field
         return 7, 0, 0
     else:
-        raise TestFailed("Unsupported SREC type %r." % typ)
+        raise TestFailed(f"Unsupported SREC type {typ!r}.")
 
 def readable_binary_string(s):
-    return "".join("%02x" % ord(c) for c in s)
+    return "".join(f"{ord(c):02x}" for c in s)
 
 class InfoTest(GdbTest):
     def test(self):
@@ -99,16 +99,16 @@ class SimpleRegisterTest(GdbTest):
     def check_reg(self, name, alias):
         a = random.randrange(1<<self.hart.xlen)
         b = random.randrange(1<<self.hart.xlen)
-        self.gdb.p("$%s=0x%x" % (name, a))
-        assertEqual(self.gdb.p("$%s" % alias), a)
+        self.gdb.p(f"${name}=0x{a:x}")
+        assertEqual(self.gdb.p(f"${alias}"), a)
         self.gdb.stepi()
-        assertEqual(self.gdb.p("$%s" % name), a)
-        assertEqual(self.gdb.p("$%s" % alias), a)
-        self.gdb.p("$%s=0x%x" % (alias, b))
-        assertEqual(self.gdb.p("$%s" % name), b)
+        assertEqual(self.gdb.p(f"${name}"), a)
+        assertEqual(self.gdb.p(f"${alias}"), a)
+        self.gdb.p(f"${alias}=0x{b:x}")
+        assertEqual(self.gdb.p(f"${name}"), b)
         self.gdb.stepi()
-        assertEqual(self.gdb.p("$%s" % name), b)
-        assertEqual(self.gdb.p("$%s" % alias), b)
+        assertEqual(self.gdb.p(f"${name}"), b)
+        assertEqual(self.gdb.p(f"${alias}"), b)
 
     def setup(self):
         self.write_nop_program(5)
@@ -140,11 +140,11 @@ class SimpleV13Test(SimpleRegisterTest):
                 written[name] = {}
                 for i in range(vlenb // byte_count):
                     written[name][i] = random.randrange(256 ** byte_count)
-                    self.gdb.p("$v13.%s[%d]=0x%x" % (name, i, written[name][i]))
+                    self.gdb.p(f"$v13.{name}[{i}]=0x{written[name][i]:x}")
                 self.gdb.stepi()
                 self.gdb.p("$v13")
                 for i in range(vlenb // byte_count):
-                    assertEqual(self.gdb.p("$v13.%s[%d]" % (name, i)),
+                    assertEqual(self.gdb.p(f"$v13.{name}[{i}]"),
                             written[name][i])
         else:
             output = self.gdb.p_raw("$v13")
@@ -154,22 +154,22 @@ class SimpleF18Test(SimpleRegisterTest):
     def check_reg(self, name, alias):
         if self.hart.extensionSupported('F'):
             mstatus_fs = 0x00006000
-            self.gdb.p("$mstatus=$mstatus|0x%x" % mstatus_fs)
+            self.gdb.p(f"$mstatus=$mstatus|0x{mstatus_fs:x}")
             self.gdb.stepi()
             a = random.random()
             b = random.random()
-            self.gdb.p_fpr("$%s=%f" % (name, a))
-            assertLess(abs((self.gdb.p_fpr("$%s" % alias)) - a), .001)
+            self.gdb.p_fpr(f"${name}={a:f}")
+            assertLess(abs((self.gdb.p_fpr(f"${alias}")) - a), .001)
             self.gdb.stepi()
-            assertLess(abs((self.gdb.p_fpr("$%s" % name)) - a), .001)
-            assertLess(abs((self.gdb.p_fpr("$%s" % alias)) - a), .001)
-            self.gdb.p_fpr("$%s=%f" % (alias, b))
-            assertLess(abs((self.gdb.p_fpr("$%s" % name)) - b), .001)
+            assertLess(abs((self.gdb.p_fpr(f"${name}")) - a), .001)
+            assertLess(abs((self.gdb.p_fpr(f"${alias}")) - a), .001)
+            self.gdb.p_fpr(f"${alias}={b:f}")
+            assertLess(abs((self.gdb.p_fpr(f"${name}")) - b), .001)
             self.gdb.stepi()
-            assertLess(abs((self.gdb.p_fpr("$%s" % name)) - b), .001)
-            assertLess(abs((self.gdb.p_fpr("$%s" % alias)) - b), .001)
+            assertLess(abs((self.gdb.p_fpr(f"${name}")) - b), .001)
+            assertLess(abs((self.gdb.p_fpr(f"${alias}")) - b), .001)
 
-            size = self.gdb.p("sizeof($%s)" % name)
+            size = self.gdb.p(f"sizeof(${name})")
             if self.hart.extensionSupported('D'):
                 assertEqual(size, 8)
             else:
@@ -209,7 +209,7 @@ class CustomRegisterTest(SimpleRegisterTest):
 
         # Now test writing
         magic = 6667
-        self.gdb.p("$custom12345=%d" % (12345 + magic))
+        self.gdb.p(f"$custom12345={12345 + magic}")
         self.gdb.stepi()
 
         self.check_custom(magic)
@@ -229,15 +229,15 @@ class SimpleNoExistTest(GdbTest):
 
 class SimpleMemoryTest(GdbTest):
     def access_test(self, size, data_type):
-        assertEqual(self.gdb.p("sizeof(%s)" % data_type), size)
+        assertEqual(self.gdb.p(f"sizeof({data_type})"), size)
         a = 0x86753095555aaaa & ((1<<(size*8))-1)
         b = 0xdeadbeef12345678 & ((1<<(size*8))-1)
         addrA = self.hart.ram
         addrB = self.hart.ram + self.hart.ram_size - size
-        self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, addrA, a))
-        self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, addrB, b))
-        assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, addrA)), a)
-        assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, addrB)), b)
+        self.gdb.p(f"*(({data_type}*)0x{addrA:x}) = 0x{a:x}")
+        self.gdb.p(f"*(({data_type}*)0x{addrB:x}) = 0x{b:x}")
+        assertEqual(self.gdb.p(f"*(({data_type}*)0x{addrA:x})"), a)
+        assertEqual(self.gdb.p(f"*(({data_type}*)0x{addrB:x})"), b)
 
 class MemTest8(SimpleMemoryTest):
     def test(self):
@@ -262,16 +262,16 @@ class MemTestReadInvalid(SimpleMemoryTest):
 
         self.write_nop_program(2)
         self.gdb.p("$s0=0x12345678")
-        self.gdb.p("*((int*)0x%x)=0xabcdef" % good_address)
+        self.gdb.p(f"*((int*)0x{good_address:x})=0xabcdef")
         # This test relies on 'gdb_report_data_abort enable' being executed in
         # the openocd.cfg file.
         try:
-            self.gdb.p("*((int*)0x%x)" % bad_address)
+            self.gdb.p(f"*((int*)0x{bad_address:x})")
             assert False, "Read should have failed."
         except testlib.CannotAccess as e:
             assertEqual(e.address, bad_address)
         self.gdb.stepi()    # Don't let gdb cache register read
-        assertEqual(self.gdb.p("*((int*)0x%x)" % good_address), 0xabcdef)
+        assertEqual(self.gdb.p(f"*((int*)0x{good_address:x})"), 0xabcdef)
         assertEqual(self.gdb.p("$s0"), 0x12345678)
 
 #class MemTestWriteInvalid(SimpleMemoryTest):
@@ -293,8 +293,8 @@ class MemTestBlockReadInvalid(GdbTest):
         return self.target.invalid_memory_returns_zero
 
     def test(self):
-        self.gdb.p("*((int*)0x%x) = 0xdeadbeef" % (self.hart.ram + 0))
-        self.gdb.p("*((int*)0x%x) = 0x12345678" % (self.hart.ram + 4))
+        self.gdb.p(f"*((int*)0x{self.hart.ram + 0:x}) = 0xdeadbeef")
+        self.gdb.p(f"*((int*)0x{self.hart.ram + 4:x}) = 0x12345678")
 
         # read before start of memory
         self.memory_test(self.hart.ram - 8,
@@ -311,10 +311,10 @@ class MemTestBlockReadInvalid(GdbTest):
                          self.hart.ram + 8,
                          self.real_values)
 
-        self.gdb.p("*((int*)0x%x) = 0xdeadbeef" %
-                (self.hart.ram + self.hart.ram_size - 8))
-        self.gdb.p("*((int*)0x%x) = 0x12345678" %
-                (self.hart.ram + self.hart.ram_size - 4))
+        self.gdb.p(f"*((int*)0x{self.hart.ram + self.hart.ram_size - 8:x}) = "
+                   "0xdeadbeef")
+        self.gdb.p(f"*((int*)0x{self.hart.ram + self.hart.ram_size - 4:x}) = "
+                   "0x12345678")
 
         # read before end of memory
         self.memory_test(self.hart.ram + self.hart.ram_size - 8,
@@ -332,12 +332,12 @@ class MemTestBlockReadInvalid(GdbTest):
                          self.zero_values)
 
     def memory_test(self, start_addr, end_addr, expected_values):
-        dump = tempfile.NamedTemporaryFile(suffix=".simdata")
-        self.gdb.command("dump verilog memory %s 0x%x 0x%x" %
-                (dump.name, start_addr, end_addr))
-        self.gdb.command("shell cat %s" % dump.name)
-        line = dump.readline()
-        line = dump.readline()
+        with tempfile.NamedTemporaryFile(suffix=".simdata") as dump:
+            self.gdb.command(f"dump verilog memory {dump.name} "
+                             f"0x{start_addr:x} 0x{end_addr:x}")
+            self.gdb.command(f"shell cat {dump.name}")
+            line = dump.readline()
+            line = dump.readline()
         assertEqual(line.strip(), expected_values)
 
 class MemTestBlock(GdbTest):
@@ -347,7 +347,7 @@ class MemTestBlock(GdbTest):
     def write(self, temporary_file):
         data = ""
         for i in range(self.length // self.line_length):
-            line_data = "".join(["%c" % random.randrange(256)
+            line_data = "".join([f"{random.randrange(256):c}"
                 for _ in range(self.line_length)])
             data += line_data
             temporary_file.write(ihex_line(i * self.line_length, 0,
@@ -358,7 +358,7 @@ class MemTestBlock(GdbTest):
     def spot_check_memory(self, data):
         increment = 19 * 4
         for offset in list(range(0, self.length, increment)) + [self.length-4]:
-            value = self.gdb.p("*((int*)0x%x)" % (self.hart.ram + offset))
+            value = self.gdb.p(f"*((int*)0x{self.hart.ram + offset:x})")
             written = ord(data[offset]) | \
                     (ord(data[offset+1]) << 8) | \
                     (ord(data[offset+2]) << 16) | \
@@ -366,33 +366,33 @@ class MemTestBlock(GdbTest):
             assertEqual(value, written)
 
     def test_block(self, extra_delay):
-        a = tempfile.NamedTemporaryFile(suffix=".ihex")
-        data = self.write(a)
+        with tempfile.NamedTemporaryFile(suffix=".ihex") as a:
+            data = self.write(a)
 
-        self.gdb.command("shell cat %s" % a.name)
-        self.gdb.command("restore %s 0x%x" % (a.name, self.hart.ram),
-                reset_delays=50 + extra_delay)
+            self.gdb.command(f"shell cat {a.name}")
+            self.gdb.command(f"restore {a.name} 0x{self.hart.ram:x}",
+                    reset_delays=50 + extra_delay)
         self.spot_check_memory(data)
 
-        b = tempfile.NamedTemporaryFile(suffix=".srec")
-        self.gdb.command("dump srec memory %s 0x%x 0x%x" % (b.name,
-            self.hart.ram, self.hart.ram + self.length), ops=self.length / 32,
-            reset_delays=100 + extra_delay)
-        self.gdb.command("shell cat %s" % b.name)
-        highest_seen = 0
-        for line in b:
-            record_type, address, line_data = srec_parse(line)
-            if record_type == 3:
-                offset = address - (self.hart.ram & 0xffffffff)
-                written_data = data[offset:offset+len(line_data)]
-                highest_seen += len(line_data)
-                if line_data != written_data:
-                    raise TestFailed(
-                            "Data mismatch at 0x%x (offset 0x%x); wrote %s but "
-                            "read %s" % (
-                                self.hart.ram + offset, offset,
-                                readable_binary_string(written_data),
-                                readable_binary_string(line_data)))
+        with tempfile.NamedTemporaryFile(suffix=".srec") as b:
+            self.gdb.command(f"dump srec memory {b.name} 0x{self.hart.ram:x} "
+                             f"0x{self.hart.ram + self.length:x}",
+                             ops=self.length / 32,
+                             reset_delays=100 + extra_delay)
+            self.gdb.command(f"shell cat {b.name}")
+            highest_seen = 0
+            for line in b:
+                record_type, address, line_data = srec_parse(line)
+                if record_type == 3:
+                    offset = address - (self.hart.ram & 0xffffffff)
+                    written_data = data[offset:offset+len(line_data)]
+                    highest_seen += len(line_data)
+                    if line_data != written_data:
+                        raise TestFailed(
+                            f"Data mismatch at 0x{self.hart.ram + offset:x} "
+                            f"(offset 0x{offset:x}); "
+                            f"wrote {readable_binary_string(written_data)} but "
+                            f"read {readable_binary_string(line_data)}")
         assertEqual(highest_seen, self.length)
 
 # Run memory block tests with different reset delays, so hopefully we hit busy
@@ -422,7 +422,7 @@ class DisconnectTest(GdbTest):
             if regname in ("mcycle", "minstret", "instret", "cycle"):
                 continue
             assertEqual(old_values[regname], new_values[regname],
-                    "Register %s didn't match" % regname)
+                    f"Register {regname} didn't match")
 
 class InstantHaltTest(GdbTest):
     def test(self):
@@ -447,10 +447,10 @@ class InstantChangePc(GdbTest):
         # 0x13 is nop
         self.gdb.command("monitor reset halt")
         self.gdb.command("flushregs")
-        self.gdb.command("p *((int*) 0x%x)=0x13" % self.hart.ram)
-        self.gdb.command("p *((int*) 0x%x)=0x13" % (self.hart.ram + 4))
-        self.gdb.command("p *((int*) 0x%x)=0x13" % (self.hart.ram + 8))
-        self.gdb.p("$pc=0x%x" % self.hart.ram)
+        self.gdb.command(f"p *((int*) 0x{self.hart.ram:x})=0x13")
+        self.gdb.command(f"p *((int*) 0x{self.hart.ram + 4:x})=0x13")
+        self.gdb.command(f"p *((int*) 0x{self.hart.ram + 8:x})=0x13")
+        self.gdb.p(f"$pc=0x{self.hart.ram:x}")
         self.gdb.stepi()
         assertEqual((self.hart.ram + 4), self.gdb.p("$pc"))
         self.gdb.stepi()
@@ -479,7 +479,7 @@ class ProgramHwWatchpoint(ProgramTest):
         output = self.gdb.c()
         assertIn("Breakpoint", output)
         assertIn("main", output)
-        self.gdb.command("delete %d" % mainbp)
+        self.gdb.command(f"delete {mainbp}")
         self.gdb.watch("counter == 5")
         # Watchpoint hits when counter becomes 5.
         output = self.gdb.c()
@@ -556,7 +556,7 @@ class DebugChangeString(DebugTest):
         text = "This little piggy went to the market."
         self.gdb.b("main:start")
         self.gdb.c()
-        self.gdb.p('fox = "%s"' % text)
+        self.gdb.p(f'fox = "{text}"')
         self.exit(0x43b497b8)
 
 class DebugTurbostep(DebugTest):
@@ -580,7 +580,7 @@ class DebugTurbostep(DebugTest):
                 jumps += 1
             last_pc = pc
         end = time.time()
-        print("%.2f seconds/step" % ((end - start) / count))
+        print(f"{(end - start) / count:.2f} seconds/step")
         # Some basic sanity that we're not running between breakpoints or
         # something.
         assertGreater(jumps, 1)
@@ -595,11 +595,11 @@ class DebugSymbols(DebugTest):
         bp = self.gdb.b("main")
         output = self.gdb.c()
         assertIn(", main ", output)
-        self.gdb.command("delete %d" % bp)
+        self.gdb.command(f"delete {bp}")
         bp = self.gdb.b("rot13")
         output = self.gdb.c()
         assertIn(", rot13 ", output)
-        self.gdb.command("delete %d" % bp)
+        self.gdb.command(f"delete {bp}")
 
 class DebugBreakpoint(DebugTest):
     def test(self):
@@ -696,11 +696,11 @@ class HwbpManual(DebugTest):
 
         tselect = 0
         while True:
-            self.gdb.p("$tselect=%d" % tselect)
+            self.gdb.p(f"$tselect={tselect}")
             value = self.gdb.p("$tselect")
             if value != tselect:
                 raise TestNotApplicable
-            self.gdb.p("$tdata1=0x%x" % tdata1)
+            self.gdb.p(f"$tdata1=0x{tdata1:x}")
             value = self.gdb.p("$tselect")
             if value == tdata1:
                 break
@@ -739,7 +739,7 @@ class Hwbp2(DebugTest):
             output = self.gdb.c()
             self.gdb.p("$pc")
             assertRegex(output, r"[bB]reakpoint")
-            assertIn("%s " % expected, output)
+            assertIn(f"{expected} ", output)
         self.gdb.command("delete")
         self.gdb.b("_exit")
         self.exit()
@@ -747,7 +747,7 @@ class Hwbp2(DebugTest):
 class TooManyHwbp(DebugTest):
     def test(self):
         for i in range(30):
-            self.gdb.hbreak("*rot13 + %d" % (i * 4))
+            self.gdb.hbreak(f"*rot13 + {i * 4}")
 
         output = self.gdb.c(checkOutput=False)
         assertIn("Cannot insert hardware breakpoint", output)
@@ -846,8 +846,8 @@ class MemorySampleTest(DebugTest):
                     previous_value = value
                 total_samples += 1
         if end and total_samples > 0:
-            print("%d samples/second" % (1000 * end[1] / (end[0] -
-                first_timestamp)))
+            samples_per_second = 1000 * end[1] / (end[0] - first_timestamp)
+            print(f"{samples_per_second} samples/second")
         else:
             raise Exception("No samples collected.")
 
@@ -875,8 +875,7 @@ class MemorySampleSingle(MemorySampleTest):
     def test(self):
         addr = self.gdb.p("&j")
         sizeof_j = self.gdb.p("sizeof(j)")
-        self.gdb.command("monitor riscv memory_sample 0 0x%x %d" % (
-                addr, sizeof_j))
+        self.gdb.command(f"monitor riscv memory_sample 0 0x{addr:x} {sizeof_j}")
 
         raw_samples = self.collect_samples()
         self.check_incrementing_samples(raw_samples, addr)
@@ -889,10 +888,10 @@ class MemorySampleMixed(MemorySampleTest):
     def test(self):
         addr = {}
         for i, name in enumerate(("j", "i32", "i64")):
-            addr[name] = self.gdb.p("&%s" % name)
-            sizeof = self.gdb.p("sizeof(%s)" % name)
-            self.gdb.command("monitor riscv memory_sample %d 0x%x %d" % (
-                    i, addr[name], sizeof))
+            addr[name] = self.gdb.p(f"&{name}")
+            sizeof = self.gdb.p(f"sizeof({name})")
+            self.gdb.command(f"monitor riscv memory_sample {i} "
+                             f"0x{addr[name]:x} {sizeof}")
 
         raw_samples = self.collect_samples()
         self.check_incrementing_samples(raw_samples, addr["j"],
@@ -909,8 +908,8 @@ class RepeatReadTest(DebugTest):
         self.gdb.c()
         mtime_addr = 0x02000000 + 0xbff8
         count = 1024
-        output = self.gdb.command("monitor riscv repeat_read %d 0x%x 4" %
-                (count, mtime_addr))
+        output = self.gdb.command(
+            f"monitor riscv repeat_read {count} 0x{mtime_addr:x} 4")
         values = []
         for line in output.splitlines():
             # Ignore warnings
@@ -930,8 +929,8 @@ class RepeatReadTest(DebugTest):
                 assertGreater(values[i], values[i-1])
                 assertLess(values[i], values[i-1] + slop)
 
-        output = self.gdb.command("monitor riscv repeat_read 0 0x%x 4" %
-                mtime_addr)
+        output = self.gdb.command(
+            f"monitor riscv repeat_read 0 0x{mtime_addr:x} 4")
         assertEqual(output, "")
 
 class Semihosting(GdbSingleHartTest):
@@ -955,18 +954,20 @@ class Semihosting(GdbSingleHartTest):
         return output
 
     def test(self):
-        temp = tempfile.NamedTemporaryFile(suffix=".data")
+        with tempfile.NamedTemporaryFile(suffix=".data") as temp:
+            self.gdb.b("main:begin")
+            self.gdb.c()
+            self.gdb.p(f'filename="{temp.name}"', ops=3)
+            self.exit()
 
-        self.gdb.b("main:begin")
-        self.gdb.c()
-        self.gdb.p('filename="%s"' % temp.name, ops=3)
-        self.exit()
+            with open(temp.name, "r", encoding='utf-8') as fd:
+                contents = fd.readlines()
 
-        contents = open(temp.name, "r").readlines()
         assertIn("Hello, world!\n", contents)
 
         # stdout should end up in the OpenOCD log
-        log = open(self.server.logname).read()
+        with open(self.server.logname, "r", encoding='utf-8') as fd:
+            log = fd.read()
         assertIn("Do re mi fa so la ti do!", log)
 
 class SemihostingFileio(Semihosting):
@@ -975,16 +976,16 @@ class SemihostingFileio(Semihosting):
         super().setup()
 
     def test(self):
-        temp = tempfile.NamedTemporaryFile(suffix=".data")
-
-        self.gdb.b("main:begin")
-        self.gdb.c()
-        self.gdb.p('filename="%s"' % temp.name, ops=3)
-        output = self.exit()
-        # stdout should end up in gdb's CLI
-        assertIn("Do re mi fa so la ti do!", output)
+        with tempfile.NamedTemporaryFile(suffix=".data") as temp:
+            self.gdb.b("main:begin")
+            self.gdb.c()
+            self.gdb.p(f'filename="{temp.name}"', ops=3)
+            output = self.exit()
+            # stdout should end up in gdb's CLI
+            assertIn("Do re mi fa so la ti do!", output)
 
-        contents = open(temp.name, "r").readlines()
+            with open(temp.name, "r", encoding='utf-8') as fd:
+                contents = fd.readlines()
         assertIn("Hello, world!\n", contents)
 
 class InterruptTest(GdbSingleHartTest):
@@ -1068,7 +1069,7 @@ class MulticoreRegTest(GdbTest):
             assertNotIn((hart.system, hart_id), hart_ids)
             hart_ids.add((hart.system, hart_id))
             for n in range(2, 32):
-                value = self.gdb.p("$x%d" % n)
+                value = self.gdb.p(f"$x{n}")
                 assertEqual(value, (hart_id << 8) + n - 1)
 
         # Confirmed that we read different register values for different harts.
@@ -1076,7 +1077,7 @@ class MulticoreRegTest(GdbTest):
 
         for hart in self.target.harts:
             self.gdb.select_hart(hart)
-            self.gdb.p("$x1=0x%x" % (hart.index * 0x1000))
+            self.gdb.p(f"$x1=0x{hart.index * 4096:x}")
             self.gdb.p("$pc=main_post_csrr")
             self.gdb.c()
         for hart in self.target.harts:
@@ -1084,7 +1085,7 @@ class MulticoreRegTest(GdbTest):
             assertIn("main", self.gdb.where())
             # Check register values.
             for n in range(1, 32):
-                value = self.gdb.p("$x%d" % n)
+                value = self.gdb.p(f"$x{n}")
                 assertEqual(value, hart.index * 0x1000 + n - 1)
 
 #class MulticoreRunHaltStepiTest(GdbTest):
@@ -1268,7 +1269,7 @@ class StepTest(GdbSingleHartTest):
         for expected in sequence:
             self.gdb.stepi()
             pc = self.gdb.p("$pc")
-            assertEqual("%x" % (pc - main_address), "%x" % expected)
+            assertEqual(f"{pc - main_address:x}", f"{expected:x}")
 
 class JumpHbreak(GdbSingleHartTest):
     """'jump' resumes execution at location. Execution stops again immediately
@@ -1313,7 +1314,7 @@ class TriggerExecuteInstant(TriggerTest):
     debug mode."""
     def test(self):
         main_address = self.gdb.p("$pc")
-        self.gdb.command("hbreak *0x%x" % (main_address + 4))
+        self.gdb.command(f"hbreak *0x{main_address + 4:x}")
         self.gdb.c()
         assertEqual(self.gdb.p("$pc"), main_address+4)
 
@@ -1336,7 +1337,7 @@ class TriggerLoadAddressInstant(TriggerTest):
         read_loop = self.gdb.p("&read_loop")
         read_again = self.gdb.p("&read_again")
         data = self.gdb.p("&data")
-        self.gdb.command("rwatch *0x%x" % data)
+        self.gdb.command(f"rwatch *0x{data:x}")
         self.gdb.c()
         # Accept hitting the breakpoint before or after the load instruction.
         assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4])
@@ -1364,7 +1365,7 @@ class TriggerStoreAddressInstant(TriggerTest):
         self.gdb.c()
         write_loop = self.gdb.p("&write_loop")
         data = self.gdb.p("&data")
-        self.gdb.command("watch *0x%x" % data)
+        self.gdb.command(f"watch *0x{data:x}")
         self.gdb.c()
 
         # Accept hitting the breakpoint before or after the store instruction.
@@ -1391,10 +1392,10 @@ class TriggerDmode(TriggerTest):
         dmode_count = 0
         i = 0
         for i in range(16):
-            tdata1 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i))
+            tdata1 = self.gdb.p(f"(({xlen_type} *)&data)[{2*i}]")
             if tdata1 == 0:
                 break
-            tdata2 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i+1))
+            tdata2 = self.gdb.p(f"(({xlen_type} *)&data)[{2*i+1}]")
 
             if tdata1 & dmode:
                 dmode_count += 1
@@ -1432,19 +1433,19 @@ class RegsTest(GdbSingleHartTest):
         output = self.gdb.c()
         assertIn("Breakpoint ", output)
         assertIn("main", output)
-        self.gdb.command("delete %d" % main_bp)
+        self.gdb.command(f"delete {main_bp}")
         self.gdb.b("handle_trap")
 
 class WriteGprs(RegsTest):
     def test(self):
         if self.hart.extensionSupported('E'):
-            regs = [("x%d" % n) for n in range(2, 16)]
+            regs = [(f"x{n}") for n in range(2, 16)]
         else:
-            regs = [("x%d" % n) for n in range(2, 32)]
+            regs = [(f"x{n}") for n in range(2, 32)]
 
         self.gdb.p("$pc=write_regs")
         for i, r in enumerate(regs):
-            self.gdb.p("$%s=%d" % (r, (0xdeadbeef<<i)+17))
+            self.gdb.p(f"${r}={(0xdeadbeef<<i)+17}")
         self.gdb.p("$x1=&data")
         self.gdb.command("b all_done")
         output = self.gdb.c()
@@ -1454,7 +1455,7 @@ class WriteGprs(RegsTest):
         self.gdb.command("x/30gx &data")
         self.gdb.command("info registers")
         for n in range(len(regs)):
-            assertEqual(self.gdb.x("(char*)(&data)+%d" % (8*n), 'g'),
+            assertEqual(self.gdb.x(f"(char*)(&data)+{8*n}", 'g'),
                     ((0xdeadbeef<<n)+17) & ((1<<self.hart.xlen)-1))
 
 class WriteCsrs(RegsTest):
@@ -1486,6 +1487,7 @@ class DownloadTest(GdbTest):
         # line above that allows for more data runs into some error I don't
         # have time to track down right now.
         #length = min(2**14, max(2**10, self.hart.ram_size - 2048))
+        # pylint: disable-next=consider-using-with
         self.download_c = tempfile.NamedTemporaryFile(prefix="download_",
                 suffix=".c", delete=False)
         self.download_c.write(b"#include <stdint.h>\n")
@@ -1496,10 +1498,10 @@ class DownloadTest(GdbTest):
         self.crc = 0
         assert length % 16 == 0
         for i in range(length // 16):
-            self.download_c.write(("  /* 0x%04x */ " % (i * 16)).encode())
+            self.download_c.write(f"  /* 0x{i * 16:04x} */ ".encode())
             for _ in range(16):
                 value = random.randrange(1<<8)
-                self.download_c.write(("0x%02x, " % value).encode())
+                self.download_c.write(f"0x{value:02x}, ".encode())
                 self.crc = binascii.crc32(struct.pack("B", value), self.crc)
             self.download_c.write(b"\n")
         self.download_c.write(b"};\n")
@@ -1518,7 +1520,7 @@ class DownloadTest(GdbTest):
                 compiled[key] = self.target.compile(hart, self.download_c.name,
                         "programs/checksum.c")
             self.gdb.select_hart(hart)
-            self.gdb.command("file %s" % compiled.get(key))
+            self.gdb.command(f"file {compiled.get(key)}")
 
         self.gdb.select_hart(self.hart)
 
@@ -1575,7 +1577,7 @@ class PrivRw(PrivTest):
         """Test reading/writing priv."""
         self.write_nop_program(4)
         for privilege in range(4):
-            self.gdb.p("$priv=%d" % privilege)
+            self.gdb.p(f"$priv={privilege}")
             self.gdb.stepi()
             actual = self.gdb.p("$priv")
             assertIn(actual, self.supported)
@@ -1596,7 +1598,7 @@ class PrivChange(PrivTest):
         self.gdb.p("$priv=3")
         main_address = self.gdb.p("$pc")
         self.gdb.stepi()
-        assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4))
+        assertEqual(f"{self.gdb.p('$pc'):x}", f"{main_address + 4:x}")
 
         # User mode
         self.gdb.p("$priv=0")
@@ -1630,7 +1632,7 @@ class TranslateTest(GdbSingleHartTest):
         else:
             satp = mode << 60
         try:
-            self.gdb.p("$satp=0x%x" % satp)
+            self.gdb.p(f"$satp=0x{satp:x}")
         except testlib.CouldNotFetch as cnf:
             raise TestNotApplicable from cnf
         readback = self.gdb.p("$satp")
@@ -1722,10 +1724,10 @@ class VectorTest(GdbSingleHartTest):
         for regname in ('$vl', '$vtype'):
             value = self.gdb.p(regname)
             assertNotEqual(value, 0)
-            self.gdb.p("%s=0" % regname)
+            self.gdb.p(f"{regname}=0")
             self.gdb.command("flushregs")
             assertEqual(self.gdb.p(regname), 0)
-            self.gdb.p("%s=0x%x" % (regname, value))
+            self.gdb.p(f"{regname}=0x{value:x}")
             self.gdb.command("flushregs")
             assertEqual(self.gdb.p(regname), value)
 
@@ -1795,7 +1797,7 @@ class FreeRtosTest(GdbTest):
         return True
 
     def test(self):
-        self.gdb.command("file %s" % self.target.freertos_binary)
+        self.gdb.command(f"file {self.target.freertos_binary}")
         self.gdb.load()
 
         output = self.gdb.command("monitor riscv_freertos_stacking mainline")
@@ -1804,7 +1806,7 @@ class FreeRtosTest(GdbTest):
         # through gdb. It only works when spike loads the ELF file itself.
         bp = self.gdb.b("main")
         self.gdb.c()
-        self.gdb.command("delete %d" % bp)
+        self.gdb.command(f"delete {bp}")
         self.gdb.p("*((int*) &use_htif) = 0")
         # Need this, otherwise gdb complains that there is no current active
         # thread.
@@ -1813,11 +1815,11 @@ class FreeRtosTest(GdbTest):
         bp = self.gdb.b("prvQueueReceiveTask")
 
         self.gdb.c()
-        self.gdb.command("delete %d" % bp)
+        self.gdb.command(f"delete {bp}")
 
         bp = self.gdb.b("prvQueueSendTask")
         self.gdb.c()
-        self.gdb.command("delete %d" % bp)
+        self.gdb.command(f"delete {bp}")
 
         # Now we know for sure at least 2 threads have executed.
 
@@ -1833,7 +1835,7 @@ class FreeRtosTest(GdbTest):
             assertIn("ucHeap", output)
             self.gdb.command("info reg mstatus")
             values[thread.id] = self.gdb.p("$s11")
-            self.gdb.p("$s11=0x%x" % (values[thread.id] ^ int(thread.id)))
+            self.gdb.p(f"$s11=0x{values[thread.id] ^ int(thread.id):x}")
 
         # Test that writing worked
         self.gdb.stepi()
diff --git a/debug/openocd.py b/debug/openocd.py
index 1b7c8fd..54b970f 100755
--- a/debug/openocd.py
+++ b/debug/openocd.py
@@ -25,7 +25,7 @@ class OpenOcdTest(testlib.BaseTest):
     def write_nops(self, count):
         for address in range(self.target.ram, self.target.ram + 4 * count, 4):
             # 0x13 is nop
-            self.cli.command("mww 0x%x 0x13" % address)
+            self.cli.command(f"mww 0x{address:x} 0x13")
 
 class RegTest(OpenOcdTest):
     def test(self):
@@ -35,7 +35,7 @@ class RegTest(OpenOcdTest):
         assertIn("x18", regs)
 
         self.cli.command("reg x18 0x11782")
-        self.cli.command("step 0x%x" % self.target.ram)
+        self.cli.command(f"step 0x{self.target.ram:x}")
 
         assertEqual(self.cli.reg("x18"), 0x11782)
 
@@ -43,7 +43,7 @@ class StepTest(OpenOcdTest):
     def test(self):
         self.write_nops(4)
 
-        self.cli.command("step 0x%x" % self.target.ram)
+        self.cli.command("step 0x{self.target.ram:x}")
         for i in range(4):
             pc = self.cli.reg("pc")
             assertEqual(pc, self.target.ram + 4 * (i+1))
@@ -53,16 +53,16 @@ class ResumeTest(OpenOcdTest):
     def test(self):
         self.write_nops(16)
 
-        self.cli.command("bp 0x%x 4" % (self.target.ram + 12))
-        self.cli.command("bp 0x%x 4" % (self.target.ram + 24))
+        self.cli.command(f"bp 0x{self.target.ram + 12:x} 4")
+        self.cli.command(f"bp 0x{self.target.ram + 24:x} 4")
 
-        self.cli.command("resume 0x%x" % self.target.ram)
+        self.cli.command(f"resume 0x{self.target.ram:x}")
         assertEqual(self.cli.reg("pc"), self.target.ram + 12)
 
         self.cli.command("resume")
         assertEqual(self.cli.reg("pc"), self.target.ram + 24)
 
-        self.cli.command("resume 0x%x" % self.target.ram)
+        self.cli.command(f"resume 0x{self.target.ram:x}")
         assertEqual(self.cli.reg("pc"), self.target.ram + 12)
 
 def main():