@@ -119,8 +119,8 @@ def test_integer_ranges(self):
 
     def test_fixedsize_int(self):
         for size in [1, 2, 4, 8]:
-            self._test_int_type(ffi, 'int%d_t' % (8*size), size, False)
-            self._test_int_type(ffi, 'uint%d_t' % (8*size), size, True)
+            self._test_int_type(ffi, f'int{8*size}_t', size, False)
+            self._test_int_type(ffi, f'uint{8*size}_t', size, True)
         self._test_int_type(ffi, 'intptr_t', SIZE_OF_PTR, False)
         self._test_int_type(ffi, 'uintptr_t', SIZE_OF_PTR, True)
         self._test_int_type(ffi, 'ptrdiff_t', SIZE_OF_PTR, False)
@@ -288,10 +288,10 @@ def test_repr(self):
         assert repr(ffi.typeof(p)) == typerepr % "int *"
         #
         p = ffi.new("int*")
-        assert repr(p) == "<cdata 'int *' owning %d bytes>" % SIZE_OF_INT
+        assert repr(p) == f"<cdata 'int *' owning {SIZE_OF_INT} bytes>"
         assert repr(ffi.typeof(p)) == typerepr % "int *"
         p = ffi.new("int**")
-        assert repr(p) == "<cdata 'int * *' owning %d bytes>" % SIZE_OF_PTR
+        assert repr(p) == f"<cdata 'int * *' owning {SIZE_OF_PTR} bytes>"
         assert repr(ffi.typeof(p)) == typerepr % "int * *"
         p = ffi.new("int [2]")
         assert repr(p) == "<cdata 'int[2]' owning %d bytes>" % (2*SIZE_OF_INT)
@@ -575,8 +575,7 @@ def test_union_simple(self):
         assert u.a == -2
         with pytest.raises((AttributeError, TypeError)):
             del u.a
-        assert repr(u) == "<cdata 'union simple_u *' owning %d bytes>" % (
-            SIZE_OF_INT,)
+        assert repr(u) == f"<cdata 'union simple_u *' owning {SIZE_OF_INT} bytes>"
 
     def test_union_opaque(self):
         pytest.raises(ffi.error, ffi.new, "union baz*")
@@ -732,8 +731,7 @@ def cb(n):
             "<cdata 'int(*)(int)' calling <function cb at 0x")
         assert ffi.typeof(p) is ffi.typeof("int(*)(int)")
         q = ffi.new("int(**)(int)", p)
-        assert repr(q) == "<cdata 'int(* *)(int)' owning %d bytes>" % (
-            SIZE_OF_PTR)
+        assert repr(q) == f"<cdata 'int(* *)(int)' owning {SIZE_OF_PTR} bytes>"
         with pytest.raises(TypeError):
             q(43)
         res = q[0](43)
@@ -984,7 +982,7 @@ def test_array_of_struct(self):
 
     def test_pointer_to_array(self):
         p = ffi.new("int(**)[5]")
-        assert repr(p) == "<cdata 'int(* *)[5]' owning %d bytes>" % SIZE_OF_PTR
+        assert repr(p) == f"<cdata 'int(* *)[5]' owning {SIZE_OF_PTR} bytes>"
 
     def test_iterate_array(self):
         a = ffi.new("char[]", b"hello")
 
@@ -131,7 +131,7 @@ def parsex(input):
     def str_if_int(x):
         if isinstance(x, str):
             return x
-        return '%d,%d' % (x & 255, x >> 8)
+        return f'{x & 255},{x >> 8}'
     return '  '.join(map(str_if_int, result))
 
 def parse_error(input, expected_msg, expected_location):
@@ -302,9 +302,9 @@ def test_error():
 
 def test_number_too_large():
     num_max = sys.maxsize
-    assert parse("char[%d]" % num_max) == [Prim(lib._CFFI_PRIM_CHAR),
-                                          '->', Array(0), num_max]
-    parse_error("char[%d]" % (num_max + 1), "number too large", 5)
+    assert parse(f"char[{num_max}]") == [Prim(lib._CFFI_PRIM_CHAR),
+                                         '->', Array(0), num_max]
+    parse_error(f"char[{num_max + 1}]", "number too large", 5)
 
 def test_complexity_limit():
     parse_error("int" + "[]" * 2500, "internal type complexity limit reached",
 
@@ -231,12 +231,12 @@ def test_macro_check_value():
     if sys.maxsize <= 2**32 or sys.platform == 'win32':
         vals.remove('-2147483648')
     ffi = FFI()
-    cdef_lines = ['#define FOO_%d_%d %s' % (i, j, vals[i])
+    cdef_lines = [f'#define FOO_{i}_{i} {vals[i]}'
                   for i in range(len(vals))
                   for j in range(len(vals))]
     ffi.cdef('\n'.join(cdef_lines))
 
-    verify_lines = ['#define FOO_%d_%d %s' % (i, j, vals[j])  # [j], not [i]
+    verify_lines = [f'#define FOO_{i}_{j} {vals[j]}'  # [j], not [i]
                     for i in range(len(vals))
                     for j in range(len(vals))]
     lib = verify(ffi, 'test_macro_check_value_ok',
@@ -249,7 +249,7 @@ def test_macro_check_value():
             c_compiler_msg += f' (0x{c_got:x})'
         #
         for i in range(len(vals)):
-            attrname = 'FOO_%d_%d' % (i, j)
+            attrname = f'FOO_{i}_{j}'
             if i == j:
                 x = getattr(lib, attrname)
                 assert x == c_got
@@ -510,9 +510,9 @@ def test_verify_anonymous_enum_with_typedef():
     assert repr(ffi.cast("e1", 2)) == "<cdata 'e1' 2: AA>"
     #
     ffi = FFI()
-    ffi.cdef("typedef enum { AA=%d } e1;" % sys.maxsize)
+    ffi.cdef(f"typedef enum {{ AA={sys.maxsize} }} e1;")
     lib = verify(ffi, 'test_verify_anonymous_enum_with_typedef2',
-                 "typedef enum { AA=%d } e1;" % sys.maxsize)
+                 f"typedef enum {{ AA={sys.maxsize} }} e1;")
     assert lib.AA == int(ffi.cast("long", sys.maxsize))
     assert ffi.sizeof("e1") == ffi.sizeof("long")
 
@@ -2579,7 +2579,7 @@ def test_convert_api_mode_builtin_function_to_cdata():
 
 def test_large_enum():
     ffi = FFI()
-    biglist = ['nn%d' % i for i in range(6000)]
+    biglist = [f'nn{i}' for i in range(6000)]
     ffi.cdef(
         """enum foo_s {{ {} }};""".format(','.join(biglist)))
     lib = verify(ffi, "test_large_enum", """
 
@@ -26,7 +26,7 @@ class FFI(FFI):
     def verify(self, preamble='', *args, **kwds):
         # HACK to reuse the tests from ../cffi0/test_verify.py
         FFI._verify_counter += 1
-        module_name = 'verify%d' % FFI._verify_counter
+        module_name = f'verify{FFI._verify_counter}'
         try:
             del self._assigned_source
         except AttributeError:
@@ -692,11 +692,11 @@ def test_global_const_int_size():
         ffi = FFI()
         if value == int(ffi.cast("long long", value)):
             if value < 0:
-                vstr = '(-%dLL-1)' % (~value,)
+                vstr = f'(-{~value}LL-1)'
             else:
-                vstr = '%dLL' % value
+                vstr = f'{value}LL'
         elif value == int(ffi.cast("unsigned long long", value)):
-            vstr = '%dULL' % value
+            vstr = f'{value}ULL'
         else:
             raise AssertionError(value)
         ffi.cdef("static const unsigned short AA;")
@@ -1734,10 +1734,10 @@ def test_enum_size():
              ('-2147483647-1', 4, -1),
              ]
     if FFI().sizeof("long") == 8:
-        cases += [('4294967296L',        8, 2**64-1),
-                  ('%dUL' % (2**64-1),   8, 2**64-1),
-                  ('-2147483649L',       8, -1),
-                  ('%dL-1L' % (1-2**63), 8, -1)]
+        cases += [('4294967296L',    8, 2**64-1),
+                  (f'{2**64-1}UL',   8, 2**64-1),
+                  ('-2147483649L',   8, -1),
+                  (f'{1-2**63}L-1L', 8, -1)]
     for hidden_value, expected_size, expected_minus1 in cases:
         if sys.platform == 'win32' and 'U' in hidden_value:
             continue   # skipped on Windows
@@ -1754,7 +1754,7 @@ def test_enum_size():
 ##    for hidden_value, expected_size, expected_minus1 in cases:
 ##        ffi = FFI()
 ##        ffi.cdef("enum foo_e { AA, BB, ... };")
-##        lib = ffi.verify("enum foo_e { AA, BB=%s };" % hidden_value)
+##        lib = ffi.verify(f"enum foo_e {{ AA, BB={hidden_value} }};")
 ##        assert lib.AA == 0
 ##        assert ffi.sizeof("enum foo_e") == expected_size
 ##        assert int(ffi.cast("enum foo_e", -1)) == expected_minus1