@@ -14,23 +14,23 @@ def main():

     split_dir = Path(args.split_dir)

     if not split_dir.exists():

-        print(f"Error: Split directory does not exist: {args.split_dir}")

+        print("Error: Split directory does not exist: {}".format(args.split_dir))

-    match_pattern = Path(split_dir, f"split.{args.test_file}a*")

+    match_pattern = Path(split_dir, "split.{}a*".format(args.test_file))

     input_files = [

-        x for x in split_dir.iterdir() if (x.is_file() and x.match(f"{match_pattern}"))

+        x for x in split_dir.iterdir() if (x.is_file() and x.match("{}".format(match_pattern)))

     ]

     if len(input_files) == 0:

-        print(f"Error: No splits matching '{args.test_file}' in: {args.split_dir}")

+        print("Error: No splits matching '{}' in: {}".format(args.test_file, args.split_dir))

         exit(1)

     test_file_path = Path(args.build_dir, args.test_file)

     try:

         test_file_path.touch(0o666, exist_ok=True)

     except FileNotFoundError:

-        print(f"Failed to create file: {test_file_path}")

+        print("Failed to create file: {}".format(test_file_path))

         exit(1)

     input_files.sort()

@@ -40,7 +40,7 @@ def main():

     test_file_path.write_bytes(file_data)

-    print(f"Assembled: '{test_file_path}'")

+    print("Assembled: '{}'".format(test_file_path))

 if __name__ == "__main__":

@@ -67,10 +67,10 @@ class TC(testcase.TestCase):

         #assert found_open_port == True

         # Prep a clamd.conf to use for most (if not all) of the tests.

-        config = f'''

+        config = '''

             Foreground yes

-            PidFile {TC.clamd_pid}

-            DatabaseDirectory {TC.path_db}

+            PidFile {pid}

+            DatabaseDirectory {dbdir}

             LogFileMaxSize 0

             LogTime yes

             #Debug yes

@@ -82,20 +82,20 @@ class TC(testcase.TestCase):

             CommandReadTimeout 1

             MaxQueue 800

             MaxConnectionQueueLength 1024

-            '''

+            '''.format(pid=TC.clamd_pid, dbdir=TC.path_db)

         if operating_system == 'windows':

             # Only have TCP socket option for Windows.

-            config += f'''

-                TCPSocket {TC.clamd_port_num}

+            config += '''

+                TCPSocket {socket}

                 TCPAddr 127.0.0.1

-                '''

+                '''.format(socket=TC.clamd_port_num)

         else:

             # Use LocalSocket for Posix, because that's what check_clamd expects.

-            config += f'''

-                LocalSocket {TC.clamd_socket}

-                TCPSocket {TC.clamd_port_num}

+            config += '''

+                LocalSocket {localsocket}

+                TCPSocket {tcpsocket}

                 TCPAddr 127.0.0.1

-                '''

+                '''.format(localsocket=TC.clamd_socket, tcpsocket=TC.clamd_port_num)

         TC.clamd_config = TC.path_tmp / 'clamd-test.conf'

         TC.clamd_config.write_text(config)

@@ -124,7 +124,7 @@ class TC(testcase.TestCase):

                 self.proc.wait(timeout=120)

                 self.proc.stdin.close()

             except OSError as exc:

-                self.log.warning(f'Unexpected exception {exc}')

+                self.log.warning('Unexpected exception {}'.format(exc))

                 pass  # ignore

             self.proc = None

         try:

@@ -142,8 +142,10 @@ class TC(testcase.TestCase):

         '''

         Start clamd

         '''

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamd} --config-file={TC.clamd_config}'

-        self.log.info(f'Starting clamd: {command}')

+        command = '{valgrind} {valgrind_args} {clamd} --config-file={clamd_config}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamd=TC.clamd, clamd_config=TC.clamd_config

+        )

+        self.log.info('Starting clamd: {}'.format(command))

         self.proc = subprocess.Popen(

             command.strip().split(' '),

             stdin=subprocess.PIPE,

@@ -163,7 +165,8 @@ class TC(testcase.TestCase):

         The first scan uses ping & wait to give clamd time to start.

         '''

         # default (filepath) mode

-        output = self.execute_command(f'{TC.clamdscan} --ping 5 --wait -c {TC.clamd_config} {scan_args}')

+        output = self.execute_command('{clamdscan} --ping 5 --wait -c {clamd_config} {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -171,7 +174,8 @@ class TC(testcase.TestCase):

             self.verify_output(output.err, expected=expected_err, unexpected=unexpected_err)

         # multi mode

-        output = self.execute_command(f'{TC.clamdscan} -c {TC.clamd_config} -m {scan_args}')

+        output = self.execute_command('{clamdscan} -c {clamd_config} -m {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -180,7 +184,8 @@ class TC(testcase.TestCase):

         if TC.has_fdpass_support:

             # fdpass

-            output = self.execute_command(f'{TC.clamdscan} -c {TC.clamd_config} --fdpass {scan_args}')

+            output = self.execute_command('{clamdscan} -c {clamd_config} --fdpass {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

             assert output.ec == expected_ec

             if expected_out != [] or unexpected_out != []:

                 self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -188,7 +193,8 @@ class TC(testcase.TestCase):

                 self.verify_output(output.err, expected=expected_err, unexpected=unexpected_err)

             # fdpass multi mode

-            output = self.execute_command(f'{TC.clamdscan} -c {TC.clamd_config} --fdpass -m {scan_args}')

+            output = self.execute_command('{clamdscan} -c {clamd_config} --fdpass -m {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

             assert output.ec == expected_ec

             if expected_out != [] or unexpected_out != []:

                 self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -196,7 +202,8 @@ class TC(testcase.TestCase):

                 self.verify_output(output.err, expected=expected_err, unexpected=unexpected_err)

         # stream

-        output = self.execute_command(f'{TC.clamdscan} -c {TC.clamd_config} --stream {scan_args}')

+        output = self.execute_command('{clamdscan} -c {clamd_config} --stream {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -204,7 +211,8 @@ class TC(testcase.TestCase):

             self.verify_output(output.err, expected=expected_err, unexpected=unexpected_err)

         # stream multi mode

-        output = self.execute_command(f'{TC.clamdscan} -c {TC.clamd_config} --stream -m {scan_args}')

+        output = self.execute_command('{clamdscan} -c {clamd_config} --stream -m {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -223,7 +231,8 @@ class TC(testcase.TestCase):

         The first scan uses ping & wait to give clamd time to start.

         '''

         # default mode

-        output = self.execute_command(f'{TC.clamdscan} --ping 5 --wait -c {TC.clamd_config} {scan_args}')

+        output = self.execute_command('{clamdscan} --ping 5 --wait -c {clamd_config} {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -231,7 +240,8 @@ class TC(testcase.TestCase):

             self.verify_output(output.err, expected=expected_err, unexpected=unexpected_err)

         # multi mode

-        output = self.execute_command(f'{TC.clamdscan} -c {TC.clamd_config} -m {scan_args}')

+        output = self.execute_command('{clamdscan} -c {clamd_config} -m {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -250,7 +260,8 @@ class TC(testcase.TestCase):

         Use ping & wait to give clamd time to start.

         '''

         # fdpass

-        output = self.execute_command(f'{TC.clamdscan} --ping 5 --wait -c {TC.clamd_config} --fdpass {scan_args}')

+        output = self.execute_command('{clamdscan} --ping 5 --wait -c {clamd_config} --fdpass {scan_args}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config, scan_args=scan_args))

         assert output.ec == expected_ec

         if expected_out != [] or unexpected_out != []:

             self.verify_output(output.out, expected=expected_out, unexpected=unexpected_out)

@@ -263,13 +274,14 @@ class TC(testcase.TestCase):

         '''

         self.step_name('clamd version test')

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamd} --config-file={TC.clamd_config} -V'

+        command = '{valgrind} {valgrind_args} {clamd} --config-file={clamd_config} -V'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamd=TC.clamd, clamd_config=TC.clamd_config)

         output = self.execute_command(command)

         assert output.ec == 0  # success

         expected_results = [

-            f'ClamAV {TC.version}',

+            'ClamAV {}'.format(TC.version),

         ]

         self.verify_output(output.out, expected=expected_results)

@@ -284,7 +296,8 @@ class TC(testcase.TestCase):

         poll = self.proc.poll()

         assert poll == None  # subprocess is alive if poll() returns None

-        output = self.execute_command(f'{TC.clamdscan} -p 5 -c {TC.clamd_config}')

+        output = self.execute_command('{clamdscan} -p 5 -c {clamd_config}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config))

         assert output.ec == 0  # success

         self.verify_output(output.out, expected=['PONG'])

@@ -308,15 +321,17 @@ class TC(testcase.TestCase):

         # First we'll ping-pong to make sure clamd is up

         # If clamd isn't up before the version test, clamdscan will return it's

         # own version, which isn't really the point of the test.

-        output = self.execute_command(f'{TC.clamdscan} --ping 5 -c {TC.clamd_config}')

+        output = self.execute_command('{clamdscan} --ping 5 -c {clamd_config}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config))

         assert output.ec == 0  # success

         self.verify_output(output.out, expected=['PONG'])

         # Ok now it's up, let's check clamd's version via clamdscan.

-        output = self.execute_command(f'{TC.clamdscan} --version -c {TC.clamd_config}')

+        output = self.execute_command('{clamdscan} --version -c {clamd_config}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config))

         assert output.ec == 0  # success

         self.verify_output(output.out,

-            expected=[f'ClamAV {TC.version}'], unexpected=['Could not connect to clamd'])

+            expected=['ClamAV {}'.format(TC.version)], unexpected=['Could not connect to clamd'])

     def test_clamd_03_reload(self):

         '''

@@ -332,19 +347,20 @@ class TC(testcase.TestCase):

         (TC.path_tmp / 'reload-testfile').write_bytes(b'ClamAV-RELOAD-Test')

-        self.run_clamdscan(f'{TC.path_tmp / "reload-testfile"}',

+        self.run_clamdscan('{}'.format(TC.path_tmp / "reload-testfile"),

             expected_ec=0, expected_out=['reload-testfile: OK', 'Infected files: 0'])

         (TC.path_db / 'reload-test.ndb').write_text('ClamAV-RELOAD-TestFile:0:0:436c616d41562d52454c4f41442d54657374')

-        output = self.execute_command(f'{TC.clamdscan} --reload -c {TC.clamd_config}')

+        output = self.execute_command('{clamdscan} --reload -c {clamd_config}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config))

         assert output.ec == 0  # success

         time.sleep(2) # give clamd a moment to reload before trying again

                       # with multi-threaded reloading will clamd would happily

                       # re-scan with the old engine while it reloads.

-        self.run_clamdscan(f'{TC.path_tmp / "reload-testfile"}',

+        self.run_clamdscan('{}'.format(TC.path_tmp / "reload-testfile"),

             expected_ec=1, expected_out=['ClamAV-RELOAD-TestFile.UNOFFICIAL FOUND', 'Infected files: 1'])

     def test_clamd_04_all_testfiles(self):

@@ -359,10 +375,10 @@ class TC(testcase.TestCase):

         assert poll == None  # subprocess is alive if poll() returns None

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        expected_results = [f'{testpath.name}: ClamAV-Test-File.UNOFFICIAL FOUND' for testpath in TC.testpaths]

-        expected_results.append(f'Infected files: {len(TC.testpaths)}')

+        expected_results = ['{}: ClamAV-Test-File.UNOFFICIAL FOUND'.format(testpath.name) for testpath in TC.testpaths]

+        expected_results.append('Infected files: {}'.format(len(TC.testpaths)))

-        self.run_clamdscan(f'{testfiles}',

+        self.run_clamdscan(testfiles,

             expected_ec=1, expected_out=expected_results)

     def test_clamd_05_check_clamd(self):

@@ -378,14 +394,15 @@ class TC(testcase.TestCase):

         assert poll == None  # subprocess is alive if poll() returns None

         # Let's first use the ping-pong test to make sure clamd is listening.

-        output = self.execute_command(f'{TC.clamdscan} -p 5 -c {TC.clamd_config}')

+        output = self.execute_command('{clamdscan} -p 5 -c {clamd_config}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config))

         assert output.ec == 0  # success

         self.verify_output(output.out, expected=['PONG'])

         # Ok now run check_clamd to have fun with clamd's API

-        output = self.execute_command(f'{TC.check_clamd}')

-        self.log.info(f'check_clamd stdout: \n{output.out}')

-        self.log.info(f'check_clamd stderr: \n{output.err}')

+        output = self.execute_command('{}'.format(TC.check_clamd))

+        self.log.info('check_clamd stdout: \n{}'.format(output.out))

+        self.log.info('check_clamd stderr: \n{}'.format(output.err))

         assert output.ec == 0  # success

         expected_results = [

@@ -394,7 +411,8 @@ class TC(testcase.TestCase):

         self.verify_output(output.out, expected=expected_results)

         # Let's do another ping-pong test to see if `check_clamd` killed clamd (Mu-ha-ha).

-        output = self.execute_command(f'{TC.clamdscan} -p 5 -c {TC.clamd_config}')

+        output = self.execute_command('{clamdscan} -p 5 -c {clamd_config}'.format(

+            clamdscan=TC.clamdscan, clamd_config=TC.clamd_config))

         assert output.ec == 0  # success

         self.verify_output(output.out, expected=['PONG'])

@@ -414,7 +432,7 @@ class TC(testcase.TestCase):

         poll = self.proc.poll()

         assert poll == None  # subprocess is alive if poll() returns None

-        self.run_clamdscan(f'{TC.path_build / "unit_tests" / "clam-phish-exe"}',

+        self.run_clamdscan('{}'.format(TC.path_build / "unit_tests" / "clam-phish-exe"),

             expected_ec=1, expected_out=['ClamAV-Test-File'])

     def test_clamd_07_HeuristicScanPrecedence_on(self):

@@ -436,7 +454,7 @@ class TC(testcase.TestCase):

         poll = self.proc.poll()

         assert poll == None  # subprocess is alive if poll() returns None

-        self.run_clamdscan(f'{TC.path_build / "unit_tests" / "clam-phish-exe"}',

+        self.run_clamdscan('{}'.format(TC.path_build / "unit_tests" / "clam-phish-exe"),

             expected_ec=1, expected_out=['Heuristics.Phishing.Email.SpoofedDomain'])

     @unittest.skipIf(operating_system == 'windows', 'This test uses a shell script to test virus-action. TODO: add Windows support to this test.')

@@ -447,17 +465,19 @@ class TC(testcase.TestCase):

         self.step_name('Testing clamd + clamdscan w/ VirusEvent')

         with TC.clamd_config.open('a') as config:

-            config.write(f'VirusEvent {TC.path_source / "unit_tests" / "virusaction-test.sh"} {TC.path_tmp} "Virus found: %v"\n')

+            config.write('VirusEvent {} {} "Virus found: %v"\n'.format(

+                TC.path_source / "unit_tests" / "virusaction-test.sh",

+                TC.path_tmp))

         self.start_clamd()

         poll = self.proc.poll()

         assert poll == None  # subprocess is alive if poll() returns None

-        self.run_clamdscan_file_only(f'{TC.path_build / "test" / "clam.exe"}',

+        self.run_clamdscan_file_only('{}'.format(TC.path_build / "test" / "clam.exe"),

             expected_ec=1)#, expected_out=['Virus found: ClamAV-Test-File.UNOFFICIAL'])

-        self.log.info(f'verifying log output from virusaction-test.sh: {str(TC.path_tmp / "test-clamd.log")}')

+        self.log.info('verifying log output from virusaction-test.sh: {}'.format(str(TC.path_tmp / "test-clamd.log")))

         self.verify_log(str(TC.path_tmp / 'test-clamd.log'),

             expected=['Virus found: ClamAV-Test-File.UNOFFICIAL'],

             unexpected=['VirusEvent incorrect', 'VirusName incorrect'])

@@ -72,13 +72,15 @@ class TC(testcase.TestCase):

     def test_clamscan_00_version(self):

         self.step_name('clamscan version test')

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -V'

+        command = '{valgrind} {valgrind_args} {clamscan} -V'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan

+        )

         output = self.execute_command(command)

         assert output.ec == 0  # success

         expected_results = [

-            f'ClamAV {TC.version}',

+            'ClamAV {}'.format(TC.version),

         ]

         self.verify_output(output.out, expected=expected_results)

@@ -86,28 +88,32 @@ class TC(testcase.TestCase):

         self.step_name('Test that clamscan alerts on all test files')

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "clamav.hdb"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "clamav.hdb", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

-        expected_results = [f'{testpath.name}: ClamAV-Test-File.UNOFFICIAL FOUND' for testpath in TC.testpaths]

-        expected_results.append(f'Scanned files: {len(TC.testpaths)}')

-        expected_results.append(f'Infected files: {len(TC.testpaths)}')

+        expected_results = ['{}: ClamAV-Test-File.UNOFFICIAL FOUND'.format(testpath.name) for testpath in TC.testpaths]

+        expected_results.append('Scanned files: {}'.format(len(TC.testpaths)))

+        expected_results.append('Infected files: {}'.format(len(TC.testpaths)))

         self.verify_output(output.out, expected=expected_results)

     def test_clamscan_02_all_testfiles_ign2(self):

         self.step_name('Test that clamscan ignores ClamAV-Test-File alerts')

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "clamav.hdb"} -d {TC.path_db / "clamav.ign2"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} -d {path_ign_db} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "clamav.hdb", path_ign_db=TC.path_db / "clamav.ign2", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

-        expected_results = [f'{testpath.name}: ClamAV-Test-File.UNOFFICIAL FOUND' for testpath in TC.testpaths]

-        expected_results.append(f'Scanned files: {len(TC.testpaths)}')

-        expected_results.append(f'Infected files: {len(TC.testpaths)}')

+        expected_results = ['{}: ClamAV-Test-File.UNOFFICIAL FOUND'.format(testpath.name) for testpath in TC.testpaths]

+        expected_results.append('Scanned files: {}'.format(len(TC.testpaths)))

+        expected_results.append('Infected files: {}'.format(len(TC.testpaths)))

         self.verify_output(output.out, expected=expected_results)

     def test_clamscan_03_phish_test_not_enabled(self):

@@ -116,7 +122,9 @@ class TC(testcase.TestCase):

         testpaths = list(TC.path_source.glob('unit_tests/input/phish-test-*'))

         testfiles = ' '.join([str(testpath) for testpath in testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "phish.pdb"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "phish.pdb", path_ign_db=TC.path_db / "clamav.ign2", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 0  # virus NOT found

@@ -133,7 +141,9 @@ class TC(testcase.TestCase):

         testpaths = list(TC.path_source.glob('unit_tests/input/phish-test-*'))

         testfiles = ' '.join([str(testpath) for testpath in testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "phish.pdb"} --alert-phishing-ssl --alert-phishing-cloak {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} --alert-phishing-ssl --alert-phishing-cloak {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "phish.pdb", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

@@ -150,13 +160,15 @@ class TC(testcase.TestCase):

         self.step_name('Test icon (.ldb + .idb) signatures')

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "icon.ldb"} -d {TC.path_db / "icon.idb"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_ldb} -d {path_idb} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_ldb=TC.path_db / "icon.ldb", path_idb=TC.path_db / "icon.idb", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

         # Use check_fpu_endian to determine expected results

-        command = f'{TC.check_fpu_endian}'

+        command = '{}'.format(TC.check_fpu_endian)

         fpu_endian_output = self.execute_command(command)

         expected_results = [

@@ -168,14 +180,16 @@ class TC(testcase.TestCase):

         else:

             expected_results.append('clam.ea06.exe: ClamAV-Test-Icon-EA0X.UNOFFICIAL FOUND')

             expected_num_infected = 4

-        expected_results.append(f'Infected files: {expected_num_infected}')

+        expected_results.append('Infected files: {}'.format(expected_num_infected))

         self.verify_output(output.out, expected=expected_results)

     def test_clamscan_06_LDB_VI(self):

         self.step_name('Test LDB VI feature')

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "Clam-VI.ldb"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "Clam-VI.ldb", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

@@ -191,7 +205,9 @@ class TC(testcase.TestCase):

         self.step_name('Test yara signature - detect TAR file magic at an offset')

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "yara-at-offset.yara"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "yara-at-offset.yara", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

@@ -207,7 +223,9 @@ class TC(testcase.TestCase):

         self.step_name('Test yara signature - detect TAR file magic in a range')

         testfiles = ' '.join([str(testpath) for testpath in TC.testpaths])

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.clamscan} -d {TC.path_db / "yara-in-range.yara"} {testfiles}'

+        command = '{valgrind} {valgrind_args} {clamscan} -d {path_db} {testfiles}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, clamscan=TC.clamscan, path_db=TC.path_db / "yara-in-range.yara", testfiles=testfiles,

+        )

         output = self.execute_command(command)

         assert output.ec == 1  # virus found

@@ -36,18 +36,22 @@ class TC(testcase.TestCase):

         TC.path_db = Path(TC.path_tmp, 'database')

         TC.freshclam_pid = Path(TC.path_tmp, 'freshclam-test.pid')

         TC.freshclam_config = Path(TC.path_tmp, 'freshclam-test.conf')

-        TC.freshclam_config.write_text(f'''

+        TC.freshclam_config.write_text('''

             DatabaseMirror 127.0.0.1

-            PidFile {TC.freshclam_pid}

+            PidFile {freshclam_pid}

             LogVerbose yes

             LogFileMaxSize 0

             LogTime yes

-            DatabaseDirectory {TC.path_db}

-            DatabaseCustomURL file://{TC.path_www / "clamav.hdb"}

+            DatabaseDirectory {path_db}

+            DatabaseCustomURL file://{file_db}

             ExcludeDatabase daily

             ExcludeDatabase main

             ExcludeDatabase bytecode

-        ''')

+        '''.format(

+            freshclam_pid=TC.freshclam_pid,

+            path_db=TC.path_db,

+            file_db=TC.path_www / "clamav.hdb",

+        ))

     @classmethod

     def tearDownClass(cls):

@@ -63,27 +67,31 @@ class TC(testcase.TestCase):

     def test_freshclam_00_version(self):

         self.step_name('freshclam version test')

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.freshclam} --config-file={TC.freshclam_config} -V'

+        command = '{valgrind} {valgrind_args} {freshclam} --config-file={freshclam_config} -V'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, freshclam=TC.freshclam, freshclam_config=TC.freshclam_config

+        )

         output = self.execute_command(command)

         assert output.ec == 0  # success

         expected_results = [

-            f'ClamAV {TC.version}',

+            'ClamAV {}'.format(TC.version),

         ]

         self.verify_output(output.out, expected=expected_results)

     def test_freshclam_01_file_copy(self):

         self.step_name('Basic freshclam test using file:// to "download" clamav.hdb')

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.freshclam} --config-file={TC.freshclam_config}'

+        command = '{valgrind} {valgrind_args} {freshclam} --config-file={freshclam_config}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, freshclam=TC.freshclam, freshclam_config=TC.freshclam_config

+        )

         output = self.execute_command(command)

         assert output.ec == 0  # success

         expected_results = [

-            f'Downloading clamav.hdb',

-            f'Database test passed.',

-            f'clamav.hdb updated',

+            'Downloading clamav.hdb',

+            'Database test passed.',

+            'clamav.hdb updated',

         ]

         self.verify_output(output.out, expected=expected_results)

@@ -39,7 +39,9 @@ class TC(testcase.TestCase):

         self.step_name('libclamav unit tests')

         # If no valgrind, valgrind nad valgrind args are empty strings

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.check_clamav}'

+        command = '{valgrind} {valgrind_args} {check_clamav}'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, check_clamav=TC.check_clamav

+        )

         output = self.execute_command(command)

         assert output.ec == 0  # success

@@ -36,18 +36,22 @@ class TC(testcase.TestCase):

         TC.path_db = TC.path_tmp / 'database'

         TC.sigtool_pid = TC.path_tmp / 'sigtool-test.pid'

         TC.sigtool_config = TC.path_tmp / 'sigtool-test.conf'

-        TC.sigtool_config.write_text(f'''

+        TC.sigtool_config.write_text('''

             DatabaseMirror 127.0.0.1

-            PidFile {TC.sigtool_pid}

+            PidFile {sigtool_pid}

             LogVerbose yes

             LogFileMaxSize 0

             LogTime yes

-            DatabaseDirectory {TC.path_db}

-            DatabaseCustomURL file://{TC.path_www}/clamav.hdb

+            DatabaseDirectory {path_db}

+            DatabaseCustomURL file://{path_www}/clamav.hdb

             ExcludeDatabase daily

             ExcludeDatabase main

             ExcludeDatabase bytecode

-        ''')

+        '''.format(

+            sigtool_pid=TC.sigtool_pid,

+            path_db=TC.path_db,

+            path_www=TC.path_www

+        ))

     @classmethod

     def tearDownClass(cls):

@@ -63,14 +67,15 @@ class TC(testcase.TestCase):

     def test_sigtool_00_version(self):

         self.step_name('sigtool version test')

-        self.log.warning(f'VG: {os.getenv("VG")}')

-        command = f'{TC.valgrind} {TC.valgrind_args} {TC.sigtool} -V'

+        self.log.warning('VG: {}'.format(os.getenv("VG")))

+        command = '{valgrind} {valgrind_args} {sigtool} -V'.format(

+            valgrind=TC.valgrind, valgrind_args=TC.valgrind_args, sigtool=TC.sigtool

+        )

         output = self.execute_command(command)

         assert output.ec == 0  # success

         expected_results = [

-            f'ClamAV {TC.version}',

+            'ClamAV {}'.format(TC.version),

         ]

         self.verify_output(output.out, expected=expected_results)

-

@@ -117,10 +117,10 @@ class TestCase(unittest.TestCase):

         if os.getenv('VALGRIND') != None:

             cls.log_suffix = '.valgrind.log'

             cls.valgrind = Path(os.getenv("VALGRIND"))

-            cls.valgrind_args = f'-v --trace-children=yes --track-fds=yes --leak-check=full '         \

-                                f'--suppressions={cls.path_source / "unit_tests" / "valgrind.supp"} ' \

-                                f'--log-file={cls.path_tmp / "valgrind.log"} '                        \

-                                f'--error-exitcode=123'

+            cls.valgrind_args = '-v --trace-children=yes --track-fds=yes --leak-check=full '                  + \

+                                '--suppressions={} '.format(cls.path_source / "unit_tests" / "valgrind.supp") + \

+                                '--log-file={} '.format(cls.path_tmp / "valgrind.log")                        + \

+                                '--error-exitcode=123'

         # cls.log.info(f"{cls.__name__} Environment:")

         # cls.log.info(f"  version:           {cls.version}")

@@ -161,7 +161,7 @@ class TestCase(unittest.TestCase):

     def setUp(self):

         print("")

-        log_path = Path(self.path_build / 'unit_tests' / f'{self._testMethodName}{self.log_suffix}')

+        log_path = Path(self.path_build / 'unit_tests' / '{}{}'.format(self._testMethodName, self.log_suffix))

         try:

             log_path.unlink()

         except Exception:

@@ -263,10 +263,10 @@ class TestCase(unittest.TestCase):

             log_file = self.path_tmp / 'valgrind.log'

         if not log_file.exists():

-            raise AssertionError(f'{log_file} not found. Valgrind failed to run?')

+            raise AssertionError('{} not found. Valgrind failed to run?'.format(log_file))

         errors = False

-        self.log.info(f'Verifying {log_file}...')

+        self.log.info('Verifying {}...'.format(log_file))

         try:

             self.verify_log(

                 str(log_file),

@@ -276,9 +276,9 @@ class TestCase(unittest.TestCase):

             )

         except AssertionError:

             self.log.warning("*" * 69)

-            self.log.warning(f'Valgrind test failed!'.center(69, ' '))

-            self.log.warning(f'Please submit this log to https://bugzilla.clamav.net:'.center(69, ' '))

-            self.log.warning(f'{log_file}'.center(69, ' '))

+            self.log.warning('Valgrind test failed!'.center(69, ' '))

+            self.log.warning('Please submit this log to https://bugzilla.clamav.net:'.center(69, ' '))

+            self.log.warning(str(log_file).center(69, ' '))

             self.log.warning("*" * 69)

             errors = True

         finally:

@@ -616,9 +616,9 @@ class Executor(object):

                 # We will likely need these for testing and can propagate them

                 # manually, like so:

                 if "LD_LIBRARY_PATH" in sys_env:

-                    cmd = f"export LD_LIBRARY_PATH={sys_env['LD_LIBRARY_PATH']} && {cmd}"

+                    cmd = "export LD_LIBRARY_PATH={} && {}".format(sys_env['LD_LIBRARY_PATH'], cmd)

                 if "DYLD_LIBRARY_PATH" in sys_env:

-                    cmd = f"export DYLD_LIBRARY_PATH={sys_env['DYLD_LIBRARY_PATH']} && {cmd}"

+                    cmd = "export DYLD_LIBRARY_PATH={} && {}".format(sys_env['DYLD_LIBRARY_PATH'], cmd)

             self._logger.debug("Run command: %s" % (cmd,))

             self._process = subprocess.Popen(

@@ -929,4 +929,3 @@ class LogChecker:

             filename,

             found_items,

         )

-