[NFC][Py Reformat] Reformat python files in llvm-test-suite

[MatzeB]

Summary

This is an ongoing series of commits that are reformatting our Python code.

Reformatting is done with black.

If you end up having problems merging this commit because you have made changes to a python file, the best way to handle that is to run git checkout --ours <yourfile> and then reformat it with black.

If you run into any problems, post to discourse about it and we will try to help.

RFC Thread below:

https://discourse.llvm.org/t/rfc-document-and-standardize-python-code-style

Specific to this change:

• Does not change third-party code in MicroBenchmarks/libs/benchmark.

Fix code to make it parseable by python3/black in the first place:

• Fixed space/tab confusion in CollectDebugInfoUsingLLDB.py.
• Change to python3 print syntax: ABI-Testsuite/sample.py, ABI-Testsuite/test/lit.site.cfg, tools/get-report-time

[thieta]

Thanks!!

ABI-Testsuite/linux-x86.py

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 from __future__ import print_function
 import os
 import sys
+
 wopt = " -w"
 test_params = {
-    "bindump" : "nm",
-    "runtool" : "", # if None, then runtool_func must exists
-    "Platform" : "linux-gcc",
-    "cxx_rtti" : "-frtti",   # option to enable rtti
-    "cxx_exceptions" : "-fexceptions",   # option to enable rtti
-    "cxx_cpp11" : "-std=c++0x" ,
+    "bindump": "nm",
+    "runtool": "",  # if None, then runtool_func must exists
+    "Platform": "linux-gcc",
+    "cxx_rtti": "-frtti",  # option to enable rtti
+    "cxx_exceptions": "-fexceptions",  # option to enable rtti
+    "cxx_cpp11": "-std=c++0x",
 }
 
+
 def build_cxx_compiler_name(cn):
     # build c++ compiler name from C compiler name
     # <prefix>clang <options> : becomes <prefix>clang -x c++ <options>
     # <prefix>gcc <options> : becomes <prefix>g++ <options>
     # <prefix>gcc-<vers> <options>: becomes <prefix>g++-<vers> <options>
 
     cnlen = len(cn)
-  if (cn == 'clang'): #plain clang
+    if cn == "clang":  # plain clang
         return "clang -x c++"
 
     idx = cn.find("clang ")
-  if (idx >= 0): # clang with some options
-    return cn[:(idx+6)] + "-x c++ " + cn[(idx+6):]
+    if idx >= 0:  # clang with some options
+        return cn[: (idx + 6)] + "-x c++ " + cn[(idx + 6) :]
 
-  idx = cn.rfind('clang')
-  if (idx == (cnlen-5)): # ends in gcc
+    idx = cn.rfind("clang")
+    if idx == (cnlen - 5):  # ends in gcc
         return cn + " -x c++"
 
-  if (cn == 'gcc'):
+    if cn == "gcc":
         return "g++"
 
-  idx = cn.rfind('gcc')
-  if (idx == (cnlen-3)): # ends in gcc
+    idx = cn.rfind("gcc")
+    if idx == (cnlen - 3):  # ends in gcc
         return cn + " -x c++"
 
     idx = cn.find("gcc ")
-  if (idx >= 0): # gcc with some options
-    return cn[:(idx+1)] + "++ " + cn[(idx+4):]
+    if idx >= 0:  # gcc with some options
+        return cn[: (idx + 1)] + "++ " + cn[(idx + 4) :]
 
     idx = cn.find("gcc-")
-  if (idx >= 0): # gcc-<version>
-    return cn[:(idx+1)] + "++" + cn[(idx+3):]
+    if idx >= 0:  # gcc-<version>
+        return cn[: (idx + 1)] + "++" + cn[(idx + 3) :]
 
     return "UNEXPECTED COMPILER"
 
+
 def build_linker_name(cn):
     # build linkercompiler name from C compiler name
     # <prefix>clang <options> : becomes <prefix>clang++ <options>
     # <prefix>gcc <options> : becomes <prefix>g++ <options>
     # <prefix>gcc-<vers> <options>: becomes <prefix>g++-<vers> <options>
 
-  if (cn == 'clang'): #plain clang
+    if cn == "clang":  # plain clang
         return "clang++"
 
     idx = cn.find("clang ")
-  if (idx >= 0): # clang with some options
-    return cn[:(idx+5)] + "++ " + cn[(idx+6):]
+    if idx >= 0:  # clang with some options
+        return cn[: (idx + 5)] + "++ " + cn[(idx + 6) :]
 
     cnlen = len(cn)
-  idx = cn.rfind('clang')
-  if (idx == (cnlen-5)): # ends in clang
+    idx = cn.rfind("clang")
+    if idx == (cnlen - 5):  # ends in clang
         return cn + "++"
 
-  return build_cxx_compiler_name(cn) # for gcc, linekr name is same as c++ compiler name
+    return build_cxx_compiler_name(
+        cn
+    )  # for gcc, linekr name is same as c++ compiler name
 
 
 import subprocess
+
 if __name__ == "__main__":
     print(sys.argv)
-  litargs = [sys.argv[0]] # args for lit.main
+    litargs = [sys.argv[0]]  # args for lit.main
     c_compiler_name = sys.argv[1].strip()
     cxx_compiler_name = build_cxx_compiler_name(c_compiler_name)
     linker_name = build_linker_name(c_compiler_name)
-  #print("C++ compiler:", cxx_compiler_name)
-  #print("linker :", linker_name)
+    # print("C++ compiler:", cxx_compiler_name)
+    # print("linker :", linker_name)
     for la in sys.argv[2:]:
         litargs.append(la)
     sys.argv = litargs
-  cmd = c_compiler_name.split() + [ "-o", "b.exe", "test/common/genselector.c"]
-  #print("cmd = ", cmd)
+    cmd = c_compiler_name.split() + ["-o", "b.exe", "test/common/genselector.c"]
+    # print("cmd = ", cmd)
     rv = subprocess.call(cmd)
-  #print("rv = " , rv)
+    # print("rv = " , rv)
     if rv != 0:
         print("compiler failed: ", cmd)
         sys.exit(1)
     rv = subprocess.call("./b.exe")
     fp = open("nselector.h")
-  fi = fp.read();
+    fi = fp.read()
     fp.close()
-  if ("LP64" in fi):
+    if "LP64" in fi:
         test_params["Mode"] = "LP64-x86"
         prf = "--check-prefix=LP64"
     else:
         # 'gcc -m32' or 'clang -m32' mode
         test_params["Mode"] = "ILP32-x86"
         prf = "--check-prefix=ILP32"
-  test_params["prefixes"] = prf;
+    test_params["prefixes"] = prf
     test_params["c_compiler"] = c_compiler_name
     test_params["cxx_compiler"] = cxx_compiler_name
     test_params["linker"] = linker_name
     test_params["Platform"] = "linux-" + cmd[0]
 
-  print("test_params = " , test_params)
+    print("test_params = ", test_params)
     builtin_parameters = {
-    'build_mode' : "Release",
-    'llvm_site_config' : os.path.join(os.getcwd(), 'lit.site.cfg'),
-    'clang_site_config': os.path.join(os.getcwd(), 'lit.site.cfg'),
-    'test_params' : test_params
+        "build_mode": "Release",
+        "llvm_site_config": os.path.join(os.getcwd(), "lit.site.cfg"),
+        "clang_site_config": os.path.join(os.getcwd(), "lit.site.cfg"),
+        "test_params": test_params,
     }
-  #print("builtin_params = " , test_params)
+    # print("builtin_params = " , test_params)
     from lit.main import main
-  main(builtin_parameters)
 
+    main(builtin_parameters)

ABI-Testsuite/sample.py

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 # This is a sample file meant to be modified for specific configurations
 
 import os
 import sys
-wopt = ""   # set to " -w", or equivalent option, to disable warnings.
+
+wopt = ""  # set to " -w", or equivalent option, to disable warnings.
 
-#skiplist = [ "test/s2_7/test_02", "test/s2_7/test_06"] # Enable to choose a 'skip list'
+# skiplist = [ "test/s2_7/test_02", "test/s2_7/test_06"] # Enable to choose a 'skip list'
 
-test_params =  {
-    'bindump': 'nm',                 # name of the nm-like tool to print symbol names
-    'cxx_rtti': '-frtti',            # option to enable rtti
-    'runtool': '',                   # leave empty for native runs. 
-                                     # Set to the name of the 'runner' tool for cross tools
-    'linker': 'clang++ -w',          # name of the linker
-    'cxx_compiler': 'clang -x c++'+wopt, # name of the C++ compiler
-    'c_compiler': 'clang'+wopt,      # name of the C compiler
-    'cxx_cpp11': '-std=c++0x',       # option to enable C++11 mode, if any 
-    'prefixes': '--check-prefix=LP64', # must be LP64 or ILP32
-    'Platform': 'linux-clang',       # just for documentation
-    'Mode': 'LP64-x86',              # must be "LP64-x86" or "ILP32-x86"
-    'cxx_exceptions': '-fexceptions' # options to enable exceptions
+test_params = {
+    "bindump": "nm",  # name of the nm-like tool to print symbol names
+    "cxx_rtti": "-frtti",  # option to enable rtti
+    "runtool": "",  # leave empty for native runs.
+    "linker": "clang++ -w",  # name of the linker
+    "cxx_compiler": "clang -x c++" + wopt,  # name of the C++ compiler
+    "c_compiler": "clang" + wopt,  # name of the C compiler
+    "cxx_cpp11": "-std=c++0x",  # option to enable C++11 mode, if any
+    "prefixes": "--check-prefix=LP64",  # must be LP64 or ILP32
+    "Platform": "linux-clang",  # just for documentation
+    "Mode": "LP64-x86",  # must be "LP64-x86" or "ILP32-x86"
+    "cxx_exceptions": "-fexceptions"  # options to enable exceptions
     # , skip_list: skiplist          # if skiplist is not empty
-    }
 
 
 import subprocess
+
 if __name__ == "__main__":
-  print "test_params = " , test_params
+    print(f"test_params = {test_params}")
     builtin_parameters = {
-    'build_mode' : "Release",
-    'llvm_site_config' : os.path.join(os.getcwd(), 'lit.site.cfg'),
-    'clang_site_config': os.path.join(os.getcwd(), 'lit.site.cfg'),
-    'test_params' : test_params
+        "build_mode": "Release",
+        "llvm_site_config": os.path.join(os.getcwd(), "lit.site.cfg"),
+        "clang_site_config": os.path.join(os.getcwd(), "lit.site.cfg"),
+        "test_params": test_params,
     }
     from lit.main import main
-  main(builtin_parameters)
 
+    main(builtin_parameters)

ABI-Testsuite/test/basic/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-config.suffixes = ['.c']
+config.suffixes = [".c"]

ABI-Testsuite/test/coll/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-config.suffixes = ['.c']
+config.suffixes = [".c"]

ABI-Testsuite/test/common/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # Skip this directory
-config.suffixes = []
+config.suffixes = []
 

ABI-Testsuite/test/lit.site.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # -*- Python -*-
 
 import lit
 
 # Configuration file for the 'lit' test runner.
 
 # name: The name of this test suite.
-config.name = 'SN C++ IA64 ABI Tests'
+config.name = "SN C++ IA64 ABI Tests"
 
 # testFormat: The test format to use to interpret tests.
 #
 # For now we require '&&' between commands, until they get globally killed and
 # the test runner updated.
-config.test_format = lit.formats.ShTest(execute_external = True)
+config.test_format = lit.formats.ShTest(execute_external=True)
 
 # suffixes: A list of file extensions to treat as test files.
-config.suffixes = ['.c', '.cpp']
+config.suffixes = [".c", ".cpp"]
 
 ###
 
 # Discover the 'clang' and 'clangcc' to use.
 
 import os
 import shutil
 
-def copyFile(srcfile,dstfile):
+
+def copyFile(srcfile, dstfile):
     try:
         shutil.copyfile(srcfile, dstfile)
     except:
         sfp = open(srcfile, "r")
-        src = sfp.read();
+        src = sfp.read()
         dfp = open(dstfile, "w")
         dfp.write(src)
         dfp.close()
-        sfp.close()    
+        sfp.close()
     return
 
+
 def generateTests():
     config = lit_config.params["test_params"]
-    
     if "skip_list" not in config or len(config["skip_list"]) == 0:
         skip_list = []
     else:
         skip_list = [os.path.normpath(tmp) for tmp in sorted(config["skip_list"])]
-    
     for root, dirs, files in os.walk("test"):
         for filename in files:
             (file_noext, ext) = os.path.splitext(filename)
             new_ext = ""
             if ext == ".x":
                 new_ext = ".c"
             elif ext == ".xpp":
                 new_ext = ".cpp"
             else:
                 # skip this file
                 continue
-            
             # Generate the full new/old filenames
             srcfile = os.path.join(root, filename)
             dstfile = os.path.join(root, file_noext + new_ext)
 
             # Algorithm for creating the files more optimally:
-            # 
+            #
             # Target file Exists:
             #  - Size is same as original
             #    - File is NOT in skip list
             #      => No action needed
             #    - File is in skip list
             #      => Append skip lines to file
             #  - Size is different from original
             #    - File is NOT in skip list
for root, dirs, files in os.walk("test"):
                 copyFile(srcfile, dstfile)
 
             # At this point we have the original file copied over, detect whether we need
             # to mark it as an expected failure
             if os.path.splitext(srcfile)[0] in skip_list:
                 # If a file is in the skip list, mark it as expected failure
                 with open(dstfile, "a") as skipfile:
                     skipfile.write("// XFAIL: *\n")
-    
     return
 
+
 def determinePlatform():
     tspec = lit_config.params["test_params"]
 
     platform = tspec["Platform"]
-    config.environment['SN_PLATFORM'] = platform
-    
+    config.environment["SN_PLATFORM"] = platform
     platform_defs = {}
 
-    platform_defs['common'] = os.path.join('%s' % os.path.dirname(os.path.realpath(__file__)), "common")
-    platform_defs['platform'] = platform
-    platform_defs['c_compiler'] = tspec["c_compiler"]
-    platform_defs['cxx_compiler'] = tspec["cxx_compiler"]
-    platform_defs['runtool'] = tspec["runtool"]
-    platform_defs['bindump'] = tspec["bindump"]
-    platform_defs['cxx_rtti'] = tspec["cxx_rtti"]
-    platform_defs['cxx_exceptions'] = tspec["cxx_exceptions"]
-    if 'linker' in tspec:
-      platform_defs['linker'] = tspec["linker"]
-    else:
-      platform_defs['linker'] = tspec["c_compiler"]
-    if 'checker' in tspec:
-      platform_defs['checker'] = tspec["checker"]
-    else:
-      platform_defs['checker'] = "grep"
-    platform_defs['prefixes'] = '--check-prefix=CHECK ' + tspec["prefixes"]
-    platform_defs['cxx_11'] = tspec["cxx_cpp11"]
+    platform_defs["common"] = os.path.join(
+        "%s" % os.path.dirname(os.path.realpath(__file__)), "common"
+    )
+    platform_defs["platform"] = platform
+    platform_defs["c_compiler"] = tspec["c_compiler"]
+    platform_defs["cxx_compiler"] = tspec["cxx_compiler"]
+    platform_defs["runtool"] = tspec["runtool"]
+    platform_defs["bindump"] = tspec["bindump"]
+    platform_defs["cxx_rtti"] = tspec["cxx_rtti"]
+    platform_defs["cxx_exceptions"] = tspec["cxx_exceptions"]
+    if "linker" in tspec:
+        platform_defs["linker"] = tspec["linker"]
+    else:
+        platform_defs["linker"] = tspec["c_compiler"]
+    if "checker" in tspec:
+        platform_defs["checker"] = tspec["checker"]
+    else:
+        platform_defs["checker"] = "grep"
+    platform_defs["prefixes"] = "--check-prefix=CHECK " + tspec["prefixes"]
+    platform_defs["cxx_11"] = tspec["cxx_cpp11"]
 
     hfp = open("selector.h", "w")
 
-    if 'compiler_flags' in tspec:
-        platform_defs['c_compiler'] = platform_defs['c_compiler'] + ' ' + tspec['compiler_flags']
-        platform_defs['cxx_compiler'] = platform_defs['cxx_compiler'] + ' ' + tspec['compiler_flags']
-    if 'linker_flags' in tspec:
-        platform_defs['linker'] = platform_defs['linker'] + ' ' + tspec['linker_flags']
+    if "compiler_flags" in tspec:
+        platform_defs["c_compiler"] = (
+            platform_defs["c_compiler"] + " " + tspec["compiler_flags"]
+        )
+        platform_defs["cxx_compiler"] = (
+            platform_defs["cxx_compiler"] + " " + tspec["compiler_flags"]
+        )
+    if "linker_flags" in tspec:
+        platform_defs["linker"] = platform_defs["linker"] + " " + tspec["linker_flags"]
 
     # possible values are LP64-x86 ILP32-x86
 
     im = tspec["Mode"]
-    if (im == "LP64-x86") :
+    if im == "LP64-x86":
         # 64 bit x86 clang3.4 mode.
         hfp.write("#define ABISELECT(a,b) a // LP64 x86\n")
-    elif (im == "ILP32-x86"):
+    elif im == "ILP32-x86":
         # 32 bit x86, Dual align
         hfp.write("#define ABISELECT(a,b) b // LP64 x86\n")
     #  #sys.exit(1)
     else:
-      print "ERROR: Invalid combination of config options. tspec= " , tspec
+        print(f"ERROR: Invalid combination of config options. tspec= {tspec}")
         sys.exit(1)
     hfp.close()
 
     return platform_defs
 
+
 # Determine which toolset to use
 tools = determinePlatform()
 generateTests()
 if not lit_config.quiet:
-    lit_config.note('using toolset:')
+    lit_config.note("using toolset:")
     for key, value in tools.items():
-        lit_config.note('\t%s => %s' % (key, value))
+        lit_config.note("\t%s => %s" % (key, value))
 for key, value in tools.items():
-    config.substitutions.append( (key, value) )
+    config.substitutions.append((key, value))

ABI-Testsuite/test/s2_4/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-config.suffixes = ['.c']
+config.suffixes = [".c"]

ABI-Testsuite/test/s2_5/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-config.suffixes = ['.c']
+config.suffixes = [".c"]

ABI-Testsuite/test/s2_6/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-config.suffixes = ['.c']
+config.suffixes = [".c"]

ABI-Testsuite/test/struct_layout_tests/PACKED/lit.local.cfg

 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-config.suffixes = ['.c']
+config.suffixes = [".c"]

CollectDebugInfoUsingLLDB.py

 #!/usr/bin/python
 
-#----------------------------------------------------------------------
-# 
+# ----------------------------------------------------------------------
+#
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Developer/Library/PrivateFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Developer/Library/PrivateFrameworks/LLDB.framework/Resources/Python
 #
 # This script collect debugging information using LLDB. This script is
 # used by TEST=dbg in llvm testsuite to measure quality of debug info in
 # optimized builds.
 #
 # Usage:
 # export PYTHONPATH=...
 # ./CollectDebugInfUsingLLDB.py program bp_file out_file
 #     program - Executable program with debug info.
 #     bp_file - Simple text file listing breakpoints.
 #               <absolute file name> <line number>
 #     out_file - Output file where the debug info will be emitted.
-#----------------------------------------------------------------------
+# ----------------------------------------------------------------------
 
 import lldb
 import os
 import sys
 import time
 
 # AlreadyPrintedValues - A place to keep track of recursive values.
 AlreadyPrintedValues = {}
 
 # ISAlreadyPrinted - Return true if value is already printed.
 def IsAlreadyPrinted(value_name):
-        if AlreadyPrintedValues.get(value_name) is None:
-                AlreadyPrintedValues[value_name] = 1
-                return False
-        return True
 
 
 # print_var_value - Print a variable's value.
-def print_var_value (v, file, frame):
-        if v.IsValid() == False:
-                return
-        if IsAlreadyPrinted(v.GetName()):
-                return
-        total_children = v.GetNumChildren()
-        if total_children > 0:
-            c = 0
-            while (c < total_children) :
-                    child = v.GetChildAtIndex(c)
-                    if child is None:
-                        file.write("None")
-                    else:
-                        if (child.GetName()) is None:
-                                file.write("None")
-                        else:
-                                file.write(child.GetName())
-                                file.write('=')
-                                print_var_value(child, file, frame)
-                                file.write(',')
-                    c = c + 1
-        else:
-            if v.GetValue(frame) is None:
-                file.write("None")
-            else:
-                file.write(v.GetValue(frame))
+def print_var_value(v, file, frame):
+        while c < total_children:
+                    file.write("=")
+                    file.write(",")
 
+
 def disable_bp(thread):
     # disable this thread.
     count = thread.GetStopReasonDataCount()
     bid = 0
     tid = 0
     for i in range(count):
         id = thread.GetStopReasonDataAtIndex(i)
         bp = target.FindBreakpointByID(id)
         if bp.IsValid():
             if bp.IsEnabled() == True:
-                    bid = bp.GetID()
-                    tid = bp.GetThreadID()
-                    bp.SetEnabled(False)
-              # print " disabled [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
+                # print " disabled [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
         else:
-            bp_loc = bp.FindLocationByID(thread.GetStopReasonDataAtIndex(i+1))
+            bp_loc = bp.FindLocationByID(thread.GetStopReasonDataAtIndex(i + 1))
             if bp_loc.IsValid():
                 bid = bp_loc.GetBreakPoint().GetID()
                 tid = bp_loc.ThreadGetID()
-                bp_loc.SetEnabled(False);
-          # print " disabled [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
+                bp_loc.SetEnabled(False)
+                # print " disabled [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
 
+
 # print_vars - Print variable values in output file.
-def print_vars (tag, vars, fname, line, file, frame, target, thread):
+def print_vars(tag, vars, fname, line, file, frame, target, thread):
 
     bid = 0
     tid = 0
     count = thread.GetStopReasonDataCount()
     # print "count = ",count
     for i in range(count):
         # print "i =", i
         id = thread.GetStopReasonDataAtIndex(i)
         bp = target.FindBreakpointByID(id)
         if bp.IsValid():
-    bid = bp.GetID()
-    tid = bp.GetThreadID()
-                # print "bp is valid", bid, tid
-    for j in range(vars.GetSize()):
-      v = vars.GetValueAtIndex(j)
-      if v.GetName() is not None:
-        file.write(tag)
-        file.write(fname)
-        file.write(':')
-        file.write(str(line))
-        file.write(' ')
-        file.write(str(tid))
-        file.write(':')
-        file.write(str(bid))
-        file.write(' ')
-        file.write(v.GetName())
-        file.write(' ')
-        AlreadyPrintedValues.clear()
-        print_var_value (v, file, frame)
-        file.write('\n')
+            bid = bp.GetID()
+            tid = bp.GetThreadID()
+            for j in range(vars.GetSize()):
+                v = vars.GetValueAtIndex(j)
+                if v.GetName() is not None:
+                    file.write(tag)
+                    file.write(fname)
+                    file.write(":")
+                    file.write(str(line))
+                    file.write(" ")
+                    file.write(str(tid))
+                    file.write(":")
+                    file.write(str(bid))
+                    file.write(" ")
+                    file.write(v.GetName())
+                    file.write(" ")
+                    AlreadyPrintedValues.clear()
+                    print_var_value(v, file, frame)
+                    file.write("\n")
+
 
 # set_breakpoints_old - set breakpoints as listed in input file.
-def set_breakpoints_old (target, breakpoint_filename, file):
+def set_breakpoints_old(target, breakpoint_filename, file):
     f = open(breakpoint_filename, "r")
     lines = f.readlines()
     for l in range(len(lines)):
         c = lines[l].split()
         # print "setting break point - ", c
-        bp = target.BreakpointCreateByLocation (str(c[0]), int(c[1]))
+        bp = target.BreakpointCreateByLocation(str(c[0]), int(c[1]))
         file.write("#Breakpoint ")
         file.write(str(c[0]))
-        file.write(':')
+        file.write(":")
         file.write(str(c[1]))
-        file.write(' ')
+        file.write(" ")
         file.write(str(bp.GetThreadID()))
-        file.write(':')
+        file.write(":")
         file.write(str(bp.GetID()))
-        file.write('\n')
+        file.write("\n")
     f.close()
 
+
 # stopeed_at_breakpoint - Return True if process is stopeed at a
 # set_breakpoints - set breakpoints as listed in input file.
-def set_breakpoints (target, breakpoint_filename, file):
+def set_breakpoints(target, breakpoint_filename, file):
     f = open(breakpoint_filename, "r")
     lines = f.readlines()
     for l in range(len(lines)):
-  l2 = len(lines[l])
-  l3 = l2 - 1
+        l2 = len(lines[l])
+        l3 = l2 - 1
         # print "setting break point - ", lines[l][0:l3]
-        bp = target.BreakpointCreateByName (str(lines[l][0:l3]))
+        bp = target.BreakpointCreateByName(str(lines[l][0:l3]))
         # print "setting break point - ", lines[l][0:l3],
-  # print " [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
+        # print " [", str(bp.GetThreadID()), ":", str(bp.GetID()), "]"
         file.write("#Breakpoint ")
         file.write(str(1))
-        file.write(':')
+        file.write(":")
         file.write(str(2))
-        file.write(' ')
+        file.write(" ")
         file.write(str(bp.GetThreadID()))
-        file.write(':')
+        file.write(":")
         file.write(str(bp.GetID()))
-        file.write(' ')
+        file.write(" ")
         file.write(str(lines[l][0:l3]))
-        file.write('\n')
+        file.write("\n")
     f.close()
 
+
 # stopeed_at_breakpoint - Return True if process is stopeed at a
 # breakpoint.
-def stopped_at_breakpoint (process):
+def stopped_at_breakpoint(process):
     # print "stopped"
     if process.IsValid():
         # print "stopped process"
         state = process.GetState()
         # print "stopped process", state
         if state == lldb.eStateStopped:
-                # print "stopped process state is stopped"
-                thread = process.GetThreadAtIndex(0)
-                if thread.IsValid():
-                        # print "thread is valid"
-                        if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
-                          # print "thread stopped at breakpoint"
-                                return True
+                    # print "thread stopped at breakpoint"
     return False
 
+
 # Create a new debugger instance
 debugger = lldb.SBDebugger.Create()
 
-# When we step or continue, don't return from the function until the process 
+# When we step or continue, don't return from the function until the process
 # stops. We do this by setting the async mode to false.
-debugger.SetAsync (False)
+debugger.SetAsync(False)
 
 # Create a target from a file and arch
 # print "Creating a target for '%s'" % sys.argv[1]
 
-target = debugger.CreateTargetWithFileAndArch (sys.argv[1], lldb.LLDB_ARCH_DEFAULT)
+target = debugger.CreateTargetWithFileAndArch(sys.argv[1], lldb.LLDB_ARCH_DEFAULT)
 
 if target.IsValid():
     # print "target is valid"
-    file=open(str(sys.argv[3]), 'w')    
-    set_breakpoints (target, sys.argv[2], file)
+    file = open(str(sys.argv[3]), "w")
+    set_breakpoints(target, sys.argv[2], file)
 
     # Launch the process. Since we specified synchronous mode, we won't return
     # from this function until we hit the breakpoint at main
     sberror = lldb.SBError()
     process = target.LaunchSimple(None, None, None)
     # Make sure the launch went ok
     while stopped_at_breakpoint(process):
         # print "stopped at a bp"
-        thread = process.GetThreadAtIndex (0)
-  # print "num of frames ", thread.GetNumFrames()
-        frame = thread.GetFrameAtIndex (0)
+        thread = process.GetThreadAtIndex(0)
+        # print "num of frames ", thread.GetNumFrames()
+        frame = thread.GetFrameAtIndex(0)
         if not frame.IsValid():
-    for fi in range(thread.GetNumFrames()):
-      # print "checking frame no : ", fi
-      frame = thread.GetFrameAtIndex(fi)
-      if frame.IsValid():
-        fi = thread.GetNumFrames()
+            for fi in range(thread.GetNumFrames()):
+                # print "checking frame no : ", fi
+                frame = thread.GetFrameAtIndex(fi)
+                if frame.IsValid():
+                    fi = thread.GetNumFrames()
         if frame.IsValid():
             # #Print some simple frame info
             ##print frame
             # print "frame is valid"
             function = frame.GetFunction()
             if function.IsValid():
                 fname = function.GetMangledName()
                 if fname is None:
                     fname = function.GetName()
                 # print "function : ",fname
                 line = frame.GetLineEntry().GetLine()
-                vars = frame.GetVariables(1,0,0,0)
-                print_vars ("#Argument ", vars, fname, line, file, frame, target, thread)
+                vars = frame.GetVariables(1, 0, 0, 0)
+                print_vars("#Argument ", vars, fname, line, file, frame, target, thread)
                 # vars = frame.GetVariables(0,1,0,0)
                 # print_vars ("#Variables ", vars, fname, line, file, frame, target, thread)
-  disable_bp(thread)
+        disable_bp(thread)
         process.Continue()
     file.close()
 
 lldb.SBDebugger.Terminate()

CompareDebugInfo.py

 #!/usr/bin/python
 from __future__ import print_function
 
 import os
 import sys
 
-DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".dbg.out"
-OPT_DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".dbg.opt.out"
-LOG_FILE="Output/" + sys.argv[1] + ".log"
-NATIVE_DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".native.dbg.out"
-NATIVE_OPT_DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".native.dbg.opt.out"
-NATIVE_LOG_FILE="Output/" + sys.argv[1] + ".native.log"
-REPORT_FILE="Output/" + sys.argv[1] + ".dbg.report.txt"
+DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".dbg.out"
+OPT_DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".dbg.opt.out"
+LOG_FILE = "Output/" + sys.argv[1] + ".log"
+NATIVE_DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".native.dbg.out"
+NATIVE_OPT_DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".native.dbg.opt.out"
+NATIVE_LOG_FILE = "Output/" + sys.argv[1] + ".native.log"
+REPORT_FILE = "Output/" + sys.argv[1] + ".dbg.report.txt"
 
+
 class BreakPoint:
     def __init__(self, bp_name):
         self.name = bp_name
         self.values = {}
         self.missing_args = []
         self.matching_args = []
         self.notmatching_args = []
         self.missing_bp = False
class BreakPoint:
 
     def getNotMatchingArgCount(self):
         if self.missing_bp == True:
             return 0
         return len(self.notmatching_args)
 
     def recordArgument(self, arg_name, value):
         self.values[arg_name] = value
-        
     def __repr__(self):
         print(self.name)
         for k, v in self.values.items():
             print(k, "=", v)
-        return ''
+        return ""
 
     def compare_args(self, other, file):
         myitems = self.values.items()
         otheritems = list(other.values.items())
         match = False
         for i, my_item in enumerate(my_items):
             if i >= len(otheritems):
                 match = True
class BreakPoint:
 
     def print_list(self, items, txt, pfile):
         if len(items) == 0:
             return
         pfile.write(self.name)
         pfile.write(txt)
         for e in items:
             pfile.write(e)
-            pfile.write(' ')
-        pfile.write('\n')
+            pfile.write(" ")
+        pfile.write("\n")
+
 
 def read_input(filename, dict):
     f = open(filename, "r")
     lines = f.readlines()
     for l in range(len(lines)):
         c = lines[l].split()
         if c[0] == "#Breakpoint":
             bp = dict.get(c[2])
             if bp is None:
                 bp = BreakPoint(c[1])
             dict[c[2]] = bp
         if c[0] == "#Argument":
             bp = dict.get(c[2])
             if bp is None:
                 bp = BreakPoint(c[1])
             dict[c[2]] = bp
             bp.recordArgument(c[3], c[4])
     return
 
+
 f1_breakpoints = {}
 read_input(DBG_OUTPUT_FILE, f1_breakpoints)
 f1_items = f1_breakpoints.items()
 
 f2_breakpoints = {}
 read_input(OPT_DBG_OUTPUT_FILE, f2_breakpoints)
 f2_items = f2_breakpoints.items()
-    
 f = open(LOG_FILE, "w")
 f.write("Log output\n")
 for id, bp in f2_items:
     bp1 = f1_breakpoints.get(id)
     if bp1 is None:
         bp.setMissing()
     else:
-        bp1.compare_args(bp,f)
+        bp1.compare_args(bp, f)
 f.close()
 
 nf1_breakpoints = {}
 read_input(NATIVE_DBG_OUTPUT_FILE, nf1_breakpoints)
 nf1_items = nf1_breakpoints.items()
 
 nf2_breakpoints = {}
 read_input(NATIVE_OPT_DBG_OUTPUT_FILE, nf2_breakpoints)
 nf2_items = nf2_breakpoints.items()
-    
 nfl = open(NATIVE_LOG_FILE, "w")
 for id, bp in nf2_items:
     bp1 = nf1_breakpoints.get(id)
     if bp1 is None:
         bp.setMissing()
     else:
-        bp1.compare_args(bp,nfl)
+        bp1.compare_args(bp, nfl)
 nfl.close()
 
 f1_arg_count = 0
 f1_matching_arg_count = 0
 f1_notmatching_arg_count = 0
 f1_missing_arg_count = 0
 for f1_item in f1_items:
     bp = f1_item[1]

 for nf1_item in nf1_items:
     bp = nf1_item[1]
     nf1_arg_count = nf1_arg_count + bp.getArgCount()
     nf1_matching_arg_count = nf1_matching_arg_count + bp.getMatchingArgCount()
     nf1_notmatching_arg_count = nf1_notmatching_arg_count + bp.getNotMatchingArgCount()
     nf1_missing_arg_count = nf1_missing_arg_count + bp.getMissingArgCount()
 
 rf = open(REPORT_FILE, "w")
-rf.write("---------------------------------------------------------------\n");
+rf.write("---------------------------------------------------------------\n")
 rf.write(">>> ========= '")
 rf.write(sys.argv[1])
 rf.write("'")
 rf.write(" Program\n")
-rf.write("---------------------------------------------------------------\n\n");
-rf.write("GCC Total Arguments: ") 
+rf.write("---------------------------------------------------------------\n\n")
+rf.write("GCC Total Arguments: ")
 rf.write(str(nf1_arg_count))
 rf.write("\n")
-rf.write("GCC Matching Arguments: ") 
+rf.write("GCC Matching Arguments: ")
 rf.write(str(nf1_matching_arg_count))
 rf.write("\n")
-rf.write("GCC Not Matching Arguments: ") 
+rf.write("GCC Not Matching Arguments: ")
 rf.write(str(nf1_notmatching_arg_count))
 rf.write("\n")
-rf.write("GCC Missing Arguments: ") 
+rf.write("GCC Missing Arguments: ")
 rf.write(str(nf1_missing_arg_count))
 rf.write("\n")
-rf.write("LLVM Total Arguments: ") 
+rf.write("LLVM Total Arguments: ")
 rf.write(str(f1_arg_count))
 rf.write("\n")
-rf.write("LLVM Matching Arguments: ") 
+rf.write("LLVM Matching Arguments: ")
 rf.write(str(f1_matching_arg_count))
 rf.write("\n")
-rf.write("LLVM Not Matching Arguments: ") 
+rf.write("LLVM Not Matching Arguments: ")
 rf.write(str(f1_notmatching_arg_count))
 rf.write("\n")
-rf.write("LLVM Missing Arguments: ") 
+rf.write("LLVM Missing Arguments: ")
 rf.write(str(f1_missing_arg_count))
 rf.write("\n")
 rf.close()

External/CUDA/lit.local.cfg

 # -*- python -*-
 
 import os
 
 cuda_env_vars = [
-    'CUDA_CACHE_DISABLE',
-    'CUDA_CACHE_MAXSIZE',
-    'CUDA_CACHE_PATH',
-    'CUDA_FORCE_PTX_JIT',
-    'CUDA_VISIBLE_DEVICES',
-    'LD_LIBRARY_PATH',
+    "CUDA_CACHE_DISABLE",
+    "CUDA_CACHE_MAXSIZE",
+    "CUDA_CACHE_PATH",
+    "CUDA_FORCE_PTX_JIT",
+    "CUDA_VISIBLE_DEVICES",
+    "LD_LIBRARY_PATH",
 ]
 
 # We need to propagate cuda environment vars to tests so we can
 # control how/where the tests get executed.
 for var in cuda_env_vars:
     if var in os.environ:
         config.environment[var] = os.environ[var]
 
 config.traditional_output = True

External/HIP/lit.local.cfg

 # -*- python -*-
 
 import os
 
 hip_env_vars = [
-    'HIP_VISIBLE_DEVICES',
-    'LD_LIBRARY_PATH',
+    "HIP_VISIBLE_DEVICES",
+    "LD_LIBRARY_PATH",
 ]
 
 for var in hip_env_vars:
     if var in os.environ:
         config.environment[var] = os.environ[var]
 
 config.traditional_output = True

FindMissingLineNo.py

 #!/usr/bin/python
 
 import os
 import sys
 
-DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".dbg.ml"
-OPT_DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".dbg.opt.ml"
-NATIVE_DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".native.dbg.ml"
-NATIVE_OPT_DBG_OUTPUT_FILE="Output/" + sys.argv[1] + ".native.dbg.opt.ml"
-XFAIL_FILE=sys.argv[2] + "/lineinfo.xfail"
+DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".dbg.ml"
+OPT_DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".dbg.opt.ml"
+NATIVE_DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".native.dbg.ml"
+NATIVE_OPT_DBG_OUTPUT_FILE = "Output/" + sys.argv[1] + ".native.dbg.opt.ml"
+XFAIL_FILE = sys.argv[2] + "/lineinfo.xfail"
 
-REPORT_FILE="Output/" + sys.argv[1] + ".dbg.missing_lines.report.txt"
+REPORT_FILE = "Output/" + sys.argv[1] + ".dbg.missing_lines.report.txt"
 
+
 def read_inputfile(filename, dict):
     f = open(filename, "r")
     lines = f.readlines()
     for l in range(len(lines)):
         columns = lines[l].split()
         s = dict.get(columns[0])
         if s is None:
             s = set()
         s.add(columns[1])
         dict[columns[0]] = s
     f.close()
     return
 
+
 dbg_lines = {}
 read_inputfile(DBG_OUTPUT_FILE, dbg_lines)
 
 dbg_opt_lines = {}
 read_inputfile(OPT_DBG_OUTPUT_FILE, dbg_opt_lines)
 
 native_dbg_lines = {}
 read_inputfile(NATIVE_DBG_OUTPUT_FILE, native_dbg_lines)

Fortran/UnitTests/fcvs21_f95/lit.local.cfg

 config.traditional_output = True
 config.single_source = True
 
 # Flang uses NO_STOP_MESSAGE to control the output of the STOP statement. If
 # it is present in the environment, we should forward it to the tests, otherwise
 # they might choke on warnings about signaling INEXACT exceptions.
-if 'NO_STOP_MESSAGE' in os.environ:
-  config.environment['NO_STOP_MESSAGE'] = os.environ['NO_STOP_MESSAGE']
+if "NO_STOP_MESSAGE" in os.environ:
+    config.environment["NO_STOP_MESSAGE"] = os.environ["NO_STOP_MESSAGE"]

Fortran/UnitTests/finalization/lit.local.cfg

 config.traditional_output = True
 config.single_source = True
 
 # Flang uses NO_STOP_MESSAGE to control the output of the STOP statement. If
 # it is present in the environment, we should forward it to the tests, otherwise
 # they might choke on warnings about signaling INEXACT exceptions.
-if 'NO_STOP_MESSAGE' in os.environ:
-  config.environment['NO_STOP_MESSAGE'] = os.environ['NO_STOP_MESSAGE']
+if "NO_STOP_MESSAGE" in os.environ:
+    config.environment["NO_STOP_MESSAGE"] = os.environ["NO_STOP_MESSAGE"]

LNTBased/Examples/Simple/TestModule

def execute_test(self, options):
         #
         # The tests should follow the current LNT test schema for reporting test
         # status (success and failure).  The current schema is that status is
         # reported as an additional test with the '.status' suffix and
         # appropriate test codes (defined by the 'lnt.testing' module, see
         # below). If no '.status' result is reported, the test is assumed to
         # have passed.
         return [
-            TestSamples('nts.LNT/Examples/Simple.compile', [1.0]),
-            TestSamples('nts.LNT/Examples/Simple.exec', [1.0]),
-            TestSamples('nts.LNT/Examples/Simple.exec.status', [FAIL])]
+            TestSamples("nts.LNT/Examples/Simple.compile", [1.0]),
+            TestSamples("nts.LNT/Examples/Simple.exec", [1.0]),
+            TestSamples("nts.LNT/Examples/Simple.exec.status", [FAIL]),
+        ]
+
 
 # This is the only required entry point to the module.
 test_class = Simple
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/lib/spec.py

def cp_rf(src, dst):
     if os.path.isfile(src):
         shutil.copy(src, dst)
     else:
         newdst = dst
         if os.path.exists(dst):
             newdst = os.path.join(dst, os.path.basename(src))
         shutil.copytree(src, newdst)
 
+
 # Test module classes are currently required to subclass 'nt.TestModule'.
 class TestModule(nt.TestModule):
 
     timeout = 5000
 
     def __init__(self):
         # The subdirectory name under externals E.g. CINT2006
-        self.suite = 'C' + self.category.upper() + str(self.year)
+        self.suite = "C" + self.category.upper() + str(self.year)
 
         # Name to identify this LNT test, e.g. nts.LNT/CINT2006_ref/456.hmmer
         self.testname = "nts.LNT/%s_ref/%s" % (self.suite, self.benchmark)
 
         # Executable name, e.g. 456.hmmer.simple
-        self.exe = self.benchmark + '.simple'
+        self.exe = self.benchmark + ".simple"
 
     def configure_test_suite(self, working_dir):
-        args = [os.path.realpath(os.path.join(self.config.test_suite_root,
-                                              'configure'))]
+        args = [
+            os.path.realpath(os.path.join(self.config.test_suite_root, "configure"))
+        ]
         if self.config.without_llvm:
-            args.extend(['--without-llvmsrc', '--without-llvmobj'])
+            args.extend(["--without-llvmsrc", "--without-llvmobj"])
         else:
-            args.extend(['--with-llvmsrc=%s' % self.config.llvm_src_root,
-                         '--with-llvmobj=%s' % self.config.llvm_obj_root])
+            args.extend(
+                [
+                    "--with-llvmsrc=%s" % self.config.llvm_src_root,
+                    "--with-llvmobj=%s" % self.config.llvm_obj_root,
+                ]
+            )
 
         if self.config.test_suite_externals:
-            args.append('--with-externals=%s' %
-                        os.path.realpath(self.config.test_suite_externals))
+            args.append(
+                "--with-externals=%s"
+                % os.path.realpath(self.config.test_suite_externals)
+            )
 
         return self.call(args, cwd=working_dir)
 
     def fail(self):
-        return [TestSamples(self.testname + '.compile.status', [FAIL])]
+        return [TestSamples(self.testname + ".compile.status", [FAIL])]
 
     def copy_input_set(self, dest_dir, size):
-        if size == 'train':
+        if size == "train":
             input_set = self.train_input_set
-        elif size == 'ref':
+        elif size == "ref":
             input_set = self.ref_input_set
         else:
-            fatal('only train and ref are supported for now')
+            fatal("only train and ref are supported for now")
 
         for f in input_set:
             cp_rf(os.path.join(self.datadir, f), dest_dir)
 
     def copy_output_set(self, dest_dir, size):
-        if size == 'train':
+        if size == "train":
             output_set = self.train_output_set
         else:
             output_set = self.ref_output_set
 
         for f in output_set:
             cp_rf(os.path.join(self.datadir, f), dest_dir)
 
     def run_safely(self, args, **kwargs):
-        if kwargs.get('shell', False):
+        if kwargs.get("shell", False):
             argstr = args
         else:
-            argstr = ' '.join(args)
-            kwargs['shell'] = True
+            argstr = " ".join(args)
+            kwargs["shell"] = True
 
-        if 'file_index' in kwargs:
-            file_index = kwargs['file_index']
+        if "file_index" in kwargs:
+            file_index = kwargs["file_index"]
             # Remove so that it can be forwarded to self.call.
-            del kwargs['file_index']
+            del kwargs["file_index"]
         else:
             file_index = 0
 
         # Generate a unique file for each training run (if requested)
-        timeit = ['LLVM_PROFILE_FILE=run_%d.profraw' % file_index,
-                  os.path.join(self.OBJROOT, 'tools', 'timeit-target')]
-
-        cwd = kwargs.get('cwd',  os.getcwd())
-        summary_file = os.path.join(cwd, 'summary_%d.time' % file_index)
-        timeit.extend(['--limit-core', '0',
-                       '--limit-cpu', str(self.timeout),
-                       '--timeout', str(self.timeout),
-                       '--limit-file-size', '104857600',
-                       '--limit-rss-size', '838860800',
-                       '--summary', summary_file])
+        timeit = [
+            "LLVM_PROFILE_FILE=run_%d.profraw" % file_index,
+            os.path.join(self.OBJROOT, "tools", "timeit-target"),
+        ]
+
+        cwd = kwargs.get("cwd", os.getcwd())
+        summary_file = os.path.join(cwd, "summary_%d.time" % file_index)
+        timeit.extend(
+            [
+                "--limit-core",
+                "0",
+                "--limit-cpu",
+                str(self.timeout),
+                "--timeout",
+                str(self.timeout),
+                "--limit-file-size",
+                "104857600",
+                "--limit-rss-size",
+                "838860800",
+                "--summary",
+                summary_file,
+            ]
+        )
         timeit.append(argstr)
-        cmdstr = ' '.join(timeit)
+        cmdstr = " ".join(timeit)
 
         if self.config.remote:
-            command_file = os.path.join(cwd, 'command_%d' % file_index)
-            with open(command_file, 'w') as f:
+            command_file = os.path.join(cwd, "command_%d" % file_index)
+            with open(command_file, "w") as f:
                 # Chdir here so that the redirects are put into CWD as well.
-                remote_command = 'cd %s\n%s\n' % (cwd, cmdstr)
-                print("command:", remote_command, file=self.log, end=' ')
+                remote_command = "cd %s\n%s\n" % (cwd, cmdstr)
+                print("command:", remote_command, file=self.log, end=" ")
                 f.write(remote_command)
 
             st = os.stat(command_file)
             os.chmod(command_file, st.st_mode | stat.S_IEXEC)
 
-            res = self.call([self.config.remote_client,
-                             '-l', self.config.remote_user,
-                             self.config.remote_host,
-                             '-p', str(self.config.remote_port),
-                             command_file])
+            res = self.call(
+                [
+                    self.config.remote_client,
+                    "-l",
+                    self.config.remote_user,
+                    "-p",
+                    str(self.config.remote_port),
+                    command_file,
+                ]
+            )
 
         else:
-            kwargs['shell'] = True
+            kwargs["shell"] = True
             res = self.call(cmdstr, **kwargs)
 
         if res != 0:
             return (res, 0)
 
-        summary = open(summary_file, 'r').readlines()
-        status = [line.split()[1] for line in summary if line.startswith('exit')]
-        assert len(status) == 1, 'incorrect exit status'
-        time = [line.split()[1] for line in summary
-                if line.startswith(self.config.test_time_stat)]
-        assert len(time) == 1, 'incorrect ellapsed time'
+        summary = open(summary_file, "r").readlines()
+        status = [line.split()[1] for line in summary if line.startswith("exit")]
+        assert len(status) == 1, "incorrect exit status"
+        time = [
+            line.split()[1]
+            for line in summary
+            if line.startswith(self.config.test_time_stat)
+        ]
+        assert len(time) == 1, "incorrect ellapsed time"
 
         return (int(status[0]), float(time[0]))
 
     def execute_test(self, options, make_variables, config):
-        MODULENAME = options['MODULENAME']
-        self.SRCROOT = options['SRCROOT']
+        MODULENAME = options["MODULENAME"]
+        self.SRCROOT = options["SRCROOT"]
         self.config = config
-        self.OBJROOT = options['OBJROOT']
-        CC = options['CC']
-        CFLAGS = options['CFLAGS']
+        self.OBJROOT = options["OBJROOT"]
+        CC = options["CC"]
+        CFLAGS = options["CFLAGS"]
         TEST_SUITE_EXTERNALS = config.test_suite_externals
 
         # test-suite-externals//speccpu2006/benchspec/CPU2006/400.perlbench vs
         # test-suite-externals//speccpu2000/benchspec/CINT2000/164.gzip
-        suitedir = os.path.join(TEST_SUITE_EXTERNALS, 'speccpu' + str(self.year), 'benchspec')
-        if self.year == '2000':
-            suitedir = os.path.join(suitedir, 'C%s2000' % self.category.upper())
+        suitedir = os.path.join(
+            TEST_SUITE_EXTERNALS, "speccpu" + str(self.year), "benchspec"
+        )
+        if self.year == "2000":
+            suitedir = os.path.join(suitedir, "C%s2000" % self.category.upper())
         else:
-            suitedir = os.path.join(suitedir, 'CPU' + self.year)
+            suitedir = os.path.join(suitedir, "CPU" + self.year)
 
-        self.datadir = os.path.join(suitedir, self.benchmark, 'data')
-        print("%s\n  options: %s\n\nmake variables: %s\n\n" % (self.testname, str(options), str(make_variables)), file=self.log)
+        self.datadir = os.path.join(suitedir, self.benchmark, "data")
+        print(
+            "%s\n  options: %s\n\nmake variables: %s\n\n"
+            % (self.testname, str(options), str(make_variables)),
+            file=self.log,
+        )
 
         if not os.path.exists(self.datadir):
-            print("skipping, no source under externals", file=self.log) 
+            print("skipping, no source under externals", file=self.log)
             return []
 
         res = self.configure_test_suite(self.OBJROOT)
         if res != 0:
             return self.fail()
 
-        make_cmd = ['make', '-k']
-        make_cmd.extend('%s=%s' % (k,v) for k,v in make_variables.items())
+        make_cmd = ["make", "-k"]
+        make_cmd.extend("%s=%s" % (k, v) for k, v in make_variables.items())
 
         # RunSafely.sh requires timeit, build it.
-        res = self.call(make_cmd + ['tools'], cwd=self.OBJROOT)
+        res = self.call(make_cmd + ["tools"], cwd=self.OBJROOT)
         if res != 0:
             return self.fail()
 
-        make_cmd.append('USE_SPEC_TEST_MODULE=1')
+        make_cmd.append("USE_SPEC_TEST_MODULE=1")
 
         # Run make clean to create the benchmark directories.
-        external_obj = os.path.join(self.OBJROOT, 'External', 'SPEC', self.suite, self.benchmark)
+        external_obj = os.path.join(
+            self.OBJROOT, "External", "SPEC", self.suite, self.benchmark
+        )
         clean_cmd = make_cmd
         external_spec_obj = os.path.split(external_obj)[0]
-        result = self.call(make_cmd + ['-C', external_spec_obj, 'clean'])
+        result = self.call(make_cmd + ["-C", external_spec_obj, "clean"])
         if result != 0:
             return self.fail()
 
         # From this on, we are operating in the 456.hmmer directory.
-        make_cmd.extend(['-C', external_obj])
-        exe_file = os.path.join('Output', self.exe)
+        make_cmd.extend(["-C", external_obj])
+        exe_file = os.path.join("Output", self.exe)
 
         if config.spec_with_pgo:
-            pgo_dir = os.path.join(self.OBJROOT, 'pgo')
+            pgo_dir = os.path.join(self.OBJROOT, "pgo")
             os.mkdir(pgo_dir)
 
-            target_flags = make_variables['TARGET_FLAGS'] + ' -fprofile-instr-generate'
+            target_flags = make_variables["TARGET_FLAGS"] + " -fprofile-instr-generate"
             pgo_make_cmd = make_cmd[:]
             pgo_make_cmd.append("TARGET_FLAGS=%s" % target_flags)
-            result = self.call(pgo_make_cmd + [ exe_file ])
+            result = self.call(pgo_make_cmd + [exe_file])
 
             exe = os.path.join(external_obj, exe_file)
             if result != 0 or not os.path.exists(exe):
                 return self.fail()
             shutil.copy(exe, pgo_dir)
 
-            self.copy_input_set(pgo_dir, 'train')
+            self.copy_input_set(pgo_dir, "train")
 
             for (i, args) in enumerate(self.train_args):
-                pgo_cmd = './%s %s' % (self.exe, args)
-                (result, time) = self.run_safely(pgo_cmd, cwd=pgo_dir, shell=True, env=os.environ, file_index=i)
+                pgo_cmd = "./%s %s" % (self.exe, args)
+                (result, time) = self.run_safely(
+                    pgo_cmd, cwd=pgo_dir, shell=True, env=os.environ, file_index=i
+                )
                 if result != 0:
                     return self.fail()
-                if not os.path.exists(os.path.join(pgo_dir, 'run_%d.profraw' % i)):
-                    print('Failed to create PGO output', file=self.log)
+                if not os.path.exists(os.path.join(pgo_dir, "run_%d.profraw" % i)):
+                    print("Failed to create PGO output", file=self.log)
                     return self.fail()
 
-            llvm_profdata = os.path.join(os.path.dirname(CC), 'llvm-profdata')
-            result = self.call(llvm_profdata + ' merge -output=code.profdata pgo/run_*.profraw', shell=True, cwd=self.OBJROOT)
+            llvm_profdata = os.path.join(os.path.dirname(CC), "llvm-profdata")
+            result = self.call(
+                llvm_profdata + " merge -output=code.profdata pgo/run_*.profraw",
+                shell=True,
+                cwd=self.OBJROOT,
+            )
             if result != 0:
                 return self.fail()
 
-            target_flags = make_variables['TARGET_FLAGS'] + ' -fprofile-instr-use=' + os.path.join(self.OBJROOT, 'code.profdata')
+            target_flags = (
+                make_variables["TARGET_FLAGS"]
+                + " -fprofile-instr-use="
+                + os.path.join(self.OBJROOT, "code.profdata")
+            )
             make_cmd.append("TARGET_FLAGS=%s" % target_flags)
 
-            result = self.call(make_cmd + ['-C', external_spec_obj, 'clean'])
+            result = self.call(make_cmd + ["-C", external_spec_obj, "clean"])
             if result != 0:
                 return self.fail()
 
         start_time = self.get_time()
-        result = self.call(make_cmd + [ exe_file ])
+        result = self.call(make_cmd + [exe_file])
         compile_time = self.get_time() - start_time
 
         exe = os.path.join(external_obj, exe_file)
         if result != 0 or not os.path.exists(exe):
             return self.fail()
 
         shutil.copy(exe, self.OBJROOT)
 
-        self.copy_input_set(self.OBJROOT, 'ref')
-        self.copy_output_set(self.OBJROOT, 'ref')
+        self.copy_input_set(self.OBJROOT, "ref")
+        self.copy_output_set(self.OBJROOT, "ref")
 
-        run_cmds = ['./%s %s' % (self.exe, args) for args in self.ref_args]
+        run_cmds = ["./%s %s" % (self.exe, args) for args in self.ref_args]
         status = PASS
 
         exec_time = 0
         for (file_index, cmd) in enumerate(run_cmds):
-            (result, time) = self.run_safely(cmd, cwd=self.OBJROOT, shell=True, file_index=file_index)
+            (result, time) = self.run_safely(
+                cmd, cwd=self.OBJROOT, shell=True, file_index=file_index
+            )
             if result != 0:
                 status = FAIL
             exec_time += time
 
-        os.environ['PATH'] += ':' + os.path.join(self.OBJROOT, 'tools')
+        os.environ["PATH"] += ":" + os.path.join(self.OBJROOT, "tools")
         for cmd in self.ref_cmp_cmds:
             if self.call(cmd, cwd=self.OBJROOT, shell=True, env=os.environ) != 0:
                 status = FAIL
 
-        result =  [
-            TestSamples(self.testname + '.compile', [compile_time]),
-            TestSamples(self.testname + '.exec', [exec_time])]
+        result = [
+            TestSamples(self.testname + ".compile", [compile_time]),
+            TestSamples(self.testname + ".exec", [exec_time]),
+        ]
         if status == FAIL:
-            result.append(TestSamples(self.testname + '.exec.status', [status]))
+            result.append(TestSamples(self.testname + ".exec.status", [status]))
 
         return result

LNTBased/speccpu2000/int/164.gzip/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_164_gzip(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '164.gzip'
-
-    train_input_set = ['train/input/input.combined']
-    train_output_set = ['train/output/input.combined.out']
-    train_args = ['input.combined 32 > 164.gzip.combined.out 2> 164.gzip.combined.err']
-    train_cmp_cmds = ['diff 164.gzip.combined.out input.combined.out --strip-trailing-cr > 164.gzip.combined.cmp']
-    ref_input_set = ['ref/input/input.graphic', 'ref/input/input.log', 'ref/input/input.program', 'ref/input/input.random', 'ref/input/input.source']
-    ref_output_set = ['ref/output/input.graphic.out', 'ref/output/input.log.out', 'ref/output/input.program.out', 'ref/output/input.random.out', 'ref/output/input.source.out']
-    ref_args = ['input.graphic 60 > 164.gzip.graphic.out 2> 164.gzip.graphic.err', 'input.log 60 > 164.gzip.log.out 2> 164.gzip.log.err', 'input.program 60 > 164.gzip.program.out 2> 164.gzip.program.err', 'input.random 60 > 164.gzip.random.out 2> 164.gzip.random.err', 'input.source 60 > 164.gzip.source.out 2> 164.gzip.source.err']
-    ref_cmp_cmds = ['diff 164.gzip.graphic.out input.graphic.out --strip-trailing-cr > 164.gzip.graphic.cmp', 'diff 164.gzip.log.out input.log.out --strip-trailing-cr > 164.gzip.log.cmp', 'diff 164.gzip.program.out input.program.out --strip-trailing-cr > 164.gzip.program.cmp', 'diff 164.gzip.random.out input.random.out --strip-trailing-cr > 164.gzip.random.cmp', 'diff 164.gzip.source.out input.source.out --strip-trailing-cr > 164.gzip.source.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "164.gzip"
+
+    train_input_set = ["train/input/input.combined"]
+    train_output_set = ["train/output/input.combined.out"]
+    train_args = ["input.combined 32 > 164.gzip.combined.out 2> 164.gzip.combined.err"]
+    train_cmp_cmds = [
+        "diff 164.gzip.combined.out input.combined.out --strip-trailing-cr > 164.gzip.combined.cmp"
+    ]
+    ref_input_set = [
+        "ref/input/input.graphic",
+        "ref/input/input.log",
+        "ref/input/input.program",
+        "ref/input/input.random",
+        "ref/input/input.source",
+    ]
+    ref_output_set = [
+        "ref/output/input.graphic.out",
+        "ref/output/input.log.out",
+        "ref/output/input.program.out",
+        "ref/output/input.random.out",
+        "ref/output/input.source.out",
+    ]
+    ref_args = [
+        "input.graphic 60 > 164.gzip.graphic.out 2> 164.gzip.graphic.err",
+        "input.log 60 > 164.gzip.log.out 2> 164.gzip.log.err",
+        "input.program 60 > 164.gzip.program.out 2> 164.gzip.program.err",
+        "input.random 60 > 164.gzip.random.out 2> 164.gzip.random.err",
+        "input.source 60 > 164.gzip.source.out 2> 164.gzip.source.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 164.gzip.graphic.out input.graphic.out --strip-trailing-cr > 164.gzip.graphic.cmp",
+        "diff 164.gzip.log.out input.log.out --strip-trailing-cr > 164.gzip.log.cmp",
+        "diff 164.gzip.program.out input.program.out --strip-trailing-cr > 164.gzip.program.cmp",
+        "diff 164.gzip.random.out input.random.out --strip-trailing-cr > 164.gzip.random.cmp",
+        "diff 164.gzip.source.out input.source.out --strip-trailing-cr > 164.gzip.source.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_164_gzip
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/175.vpr/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_175_vpr(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '175.vpr'
-
-    train_input_set = ['train/input/net.in', 'train/input/arch.in', 'train/input/place.in']
-    train_output_set = ['train/output/place_log.out']
-    train_args = ['net.in arch.in place.in dum.out -nodisp -place_only -init_t 5 -exit_t 0.005 -alpha_t 0.9412 -inner_num 2 > 175.vpr.place.out 2> 175.vpr.place.err', 'net.in arch.in place.in route.out -nodisp -route_only -route_chan_width 15 -pres_fac_mult 2 -acc_fac 1 -first_iter_pres_fac 4 -initial_pres_fac 8 > 175.vpr.route.out 2> 175.vpr.route.err']
-    train_cmp_cmds = ['diff 175.vpr.place.out place_log.out --strip-trailing-cr > 175.vpr.place.cmp']
-    ref_input_set = ['ref/input/net.in', 'ref/input/arch.in', 'ref/input/place.in']
-    ref_output_set = ['ref/output/place_log.out']
-    ref_args = ['net.in arch.in place.in dum.out -nodisp -place_only -init_t 5 -exit_t 0.005 -alpha_t 0.9412 -inner_num 2 > 175.vpr.place.out 2> 175.vpr.place.err', 'net.in arch.in place.in route.out -nodisp -route_only -route_chan_width 15 -pres_fac_mult 2 -acc_fac 1 -first_iter_pres_fac 4 -initial_pres_fac 8 > 175.vpr.route.out 2> 175.vpr.route.err']
-    ref_cmp_cmds = ['diff 175.vpr.place.out place_log.out --strip-trailing-cr > 175.vpr.place.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "175.vpr"
+
+    train_input_set = [
+        "train/input/net.in",
+        "train/input/arch.in",
+        "train/input/place.in",
+    ]
+    train_output_set = ["train/output/place_log.out"]
+    train_args = [
+        "net.in arch.in place.in dum.out -nodisp -place_only -init_t 5 -exit_t 0.005 -alpha_t 0.9412 -inner_num 2 > 175.vpr.place.out 2> 175.vpr.place.err",
+        "net.in arch.in place.in route.out -nodisp -route_only -route_chan_width 15 -pres_fac_mult 2 -acc_fac 1 -first_iter_pres_fac 4 -initial_pres_fac 8 > 175.vpr.route.out 2> 175.vpr.route.err",
+    ]
+    train_cmp_cmds = [
+        "diff 175.vpr.place.out place_log.out --strip-trailing-cr > 175.vpr.place.cmp"
+    ]
+    ref_input_set = ["ref/input/net.in", "ref/input/arch.in", "ref/input/place.in"]
+    ref_output_set = ["ref/output/place_log.out"]
+    ref_args = [
+        "net.in arch.in place.in dum.out -nodisp -place_only -init_t 5 -exit_t 0.005 -alpha_t 0.9412 -inner_num 2 > 175.vpr.place.out 2> 175.vpr.place.err",
+        "net.in arch.in place.in route.out -nodisp -route_only -route_chan_width 15 -pres_fac_mult 2 -acc_fac 1 -first_iter_pres_fac 4 -initial_pres_fac 8 > 175.vpr.route.out 2> 175.vpr.route.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 175.vpr.place.out place_log.out --strip-trailing-cr > 175.vpr.place.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_175_vpr
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/176.gcc/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_176_gcc(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '176.gcc'
-
-    train_input_set = ['train/input/cp-decl.i']
-    train_output_set = ['train/output/cp-decl.s']
-    train_args = ['cp-decl.i -o - > 176.gcc.cp-decl.out 2> 176.gcc.cp-decl.err']
-    train_cmp_cmds = ['diff 176.gcc.cp-decl.out cp-decl.s --strip-trailing-cr > 176.gcc.cp-decl.cmp']
-    ref_input_set = ['ref/input/166.i', 'ref/input/200.i', 'ref/input/expr.i', 'ref/input/integrate.i', 'ref/input/scilab.i']
-    ref_output_set = ['ref/output/166.s', 'ref/output/200.s', 'ref/output/expr.s', 'ref/output/integrate.s', 'ref/output/scilab.s']
-    ref_args = ['166.i -o - > 176.gcc.166.out 2> 176.gcc.166.err', '200.i -o - > 176.gcc.200.out 2> 176.gcc.200.err', 'expr.i -o - > 176.gcc.expr.out 2> 176.gcc.expr.err', 'integrate.i -o - > 176.gcc.integrate.out 2> 176.gcc.integrate.err', 'scilab.i -o - > 176.gcc.scilab.out 2> 176.gcc.scilab.err']
-    ref_cmp_cmds = ['diff 176.gcc.166.out 166.s --strip-trailing-cr > 176.gcc.166.cmp', 'diff 176.gcc.200.out 200.s --strip-trailing-cr > 176.gcc.200.cmp', 'diff 176.gcc.expr.out expr.s --strip-trailing-cr > 176.gcc.expr.cmp', 'diff 176.gcc.integrate.out integrate.s --strip-trailing-cr > 176.gcc.integrate.cmp', 'diff 176.gcc.scilab.out scilab.s --strip-trailing-cr > 176.gcc.scilab.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "176.gcc"
+
+    train_input_set = ["train/input/cp-decl.i"]
+    train_output_set = ["train/output/cp-decl.s"]
+    train_args = ["cp-decl.i -o - > 176.gcc.cp-decl.out 2> 176.gcc.cp-decl.err"]
+    train_cmp_cmds = [
+        "diff 176.gcc.cp-decl.out cp-decl.s --strip-trailing-cr > 176.gcc.cp-decl.cmp"
+    ]
+    ref_input_set = [
+        "ref/input/166.i",
+        "ref/input/200.i",
+        "ref/input/expr.i",
+        "ref/input/integrate.i",
+        "ref/input/scilab.i",
+    ]
+    ref_output_set = [
+        "ref/output/166.s",
+        "ref/output/200.s",
+        "ref/output/expr.s",
+        "ref/output/integrate.s",
+        "ref/output/scilab.s",
+    ]
+    ref_args = [
+        "166.i -o - > 176.gcc.166.out 2> 176.gcc.166.err",
+        "200.i -o - > 176.gcc.200.out 2> 176.gcc.200.err",
+        "expr.i -o - > 176.gcc.expr.out 2> 176.gcc.expr.err",
+        "integrate.i -o - > 176.gcc.integrate.out 2> 176.gcc.integrate.err",
+        "scilab.i -o - > 176.gcc.scilab.out 2> 176.gcc.scilab.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 176.gcc.166.out 166.s --strip-trailing-cr > 176.gcc.166.cmp",
+        "diff 176.gcc.200.out 200.s --strip-trailing-cr > 176.gcc.200.cmp",
+        "diff 176.gcc.expr.out expr.s --strip-trailing-cr > 176.gcc.expr.cmp",
+        "diff 176.gcc.integrate.out integrate.s --strip-trailing-cr > 176.gcc.integrate.cmp",
+        "diff 176.gcc.scilab.out scilab.s --strip-trailing-cr > 176.gcc.scilab.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_176_gcc
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/181.mcf/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_181_mcf(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '181.mcf'
-
-    train_input_set = ['train/input/inp.in']
-    train_output_set = ['train/output/inp.out']
-    train_args = ['inp.in > 181.mcf.inp.out 2> 181.mcf.inp.err']
-    train_cmp_cmds = ['diff 181.mcf.inp.out inp.out --strip-trailing-cr > 181.mcf.inp.cmp']
-    ref_input_set = ['ref/input/inp.in']
-    ref_output_set = ['ref/output/inp.out']
-    ref_args = ['inp.in > 181.mcf.inp.out 2> 181.mcf.inp.err']
-    ref_cmp_cmds = ['diff 181.mcf.inp.out inp.out --strip-trailing-cr > 181.mcf.inp.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "181.mcf"
+
+    train_input_set = ["train/input/inp.in"]
+    train_output_set = ["train/output/inp.out"]
+    train_args = ["inp.in > 181.mcf.inp.out 2> 181.mcf.inp.err"]
+    train_cmp_cmds = [
+        "diff 181.mcf.inp.out inp.out --strip-trailing-cr > 181.mcf.inp.cmp"
+    ]
+    ref_input_set = ["ref/input/inp.in"]
+    ref_output_set = ["ref/output/inp.out"]
+    ref_args = ["inp.in > 181.mcf.inp.out 2> 181.mcf.inp.err"]
+    ref_cmp_cmds = [
+        "diff 181.mcf.inp.out inp.out --strip-trailing-cr > 181.mcf.inp.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_181_mcf
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/186.crafty/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_186_crafty(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '186.crafty'
-
-    train_input_set = ['train/input/crafty.in']
-    train_output_set = ['train/output/crafty.out']
-    train_args = ['< crafty.in > 186.crafty.crafty.out 2> 186.crafty.crafty.err']
-    train_cmp_cmds = ['diff 186.crafty.crafty.out crafty.out --strip-trailing-cr > 186.crafty.crafty.cmp']
-    ref_input_set = ['ref/input/crafty.in']
-    ref_output_set = ['ref/output/crafty.out']
-    ref_args = ['< crafty.in > 186.crafty.crafty.out 2> 186.crafty.crafty.err']
-    ref_cmp_cmds = ['diff 186.crafty.crafty.out crafty.out --strip-trailing-cr > 186.crafty.crafty.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "186.crafty"
+
+    train_input_set = ["train/input/crafty.in"]
+    train_output_set = ["train/output/crafty.out"]
+    train_args = ["< crafty.in > 186.crafty.crafty.out 2> 186.crafty.crafty.err"]
+    train_cmp_cmds = [
+        "diff 186.crafty.crafty.out crafty.out --strip-trailing-cr > 186.crafty.crafty.cmp"
+    ]
+    ref_input_set = ["ref/input/crafty.in"]
+    ref_output_set = ["ref/output/crafty.out"]
+    ref_args = ["< crafty.in > 186.crafty.crafty.out 2> 186.crafty.crafty.err"]
+    ref_cmp_cmds = [
+        "diff 186.crafty.crafty.out crafty.out --strip-trailing-cr > 186.crafty.crafty.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_186_crafty
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/197.parser/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_197_parser(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '197.parser'
-
-    train_input_set = ['all/input/2.1.dict', 'all/input/words', 'train/input/train.in']
-    train_output_set = ['train/output/train.out']
-    train_args = ['< train.in 2.1.dict -batch > 197.parser.train.out 2> 197.parser.train.err']
-    train_cmp_cmds = ['diff 197.parser.train.out train.out --strip-trailing-cr > 197.parser.train.cmp']
-    ref_input_set = ['all/input/2.1.dict', 'all/input/words', 'ref/input/ref.in']
-    ref_output_set = ['ref/output/ref.out']
-    ref_args = ['< ref.in 2.1.dict -batch > 197.parser.ref.out 2> 197.parser.ref.err']
-    ref_cmp_cmds = ['diff 197.parser.ref.out ref.out --strip-trailing-cr > 197.parser.ref.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "197.parser"
+
+    train_input_set = ["all/input/2.1.dict", "all/input/words", "train/input/train.in"]
+    train_output_set = ["train/output/train.out"]
+    train_args = [
+        "< train.in 2.1.dict -batch > 197.parser.train.out 2> 197.parser.train.err"
+    ]
+    train_cmp_cmds = [
+        "diff 197.parser.train.out train.out --strip-trailing-cr > 197.parser.train.cmp"
+    ]
+    ref_input_set = ["all/input/2.1.dict", "all/input/words", "ref/input/ref.in"]
+    ref_output_set = ["ref/output/ref.out"]
+    ref_args = ["< ref.in 2.1.dict -batch > 197.parser.ref.out 2> 197.parser.ref.err"]
+    ref_cmp_cmds = [
+        "diff 197.parser.ref.out ref.out --strip-trailing-cr > 197.parser.ref.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_197_parser
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/252.eon/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_252_eon(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '252.eon'
-
-    train_input_set = ['train/input/chair.camera', 'train/input/chair.control.cook', 'train/input/chair.control.kajiya', 'train/input/chair.control.rushmeier', 'train/input/chair.surfaces', 'train/input/eon.dat', 'train/input/materials', 'train/input/spectra.dat']
-    train_output_set = ['train/output/pixels_out.cook', 'train/output/pixels_out.kajiya', 'train/output/pixels_out.rushmeier']
-    train_args = ['chair.control.cook chair.camera chair.surfaces chair.cook.ppm ppm pixels_out.cook > 252.eon.cook.out 2> 252.eon.cook.err', 'chair.control.kajiya chair.camera chair.surfaces chair.kajiya.ppm ppm pixels_out.kajiya > 252.eon.kajiya.out 2> 252.eon.kajiya.err', 'chair.control.rushmeier chair.camera chair.surfaces chair.rushmeier.ppm ppm pixels_out.rushmeier > 252.eon.rushmeier.out 2> 252.eon.rushmeier.err']
-    train_cmp_cmds = ['fpcmp -a 0.005 pixels_out.cook pixels_out.cook > 252.eon.cook.cmp', 'fpcmp -a 0.005 pixels_out.kajiya pixels_out.kajiya > 252.eon.kajiya.cmp', 'fpcmp -a 0.005 pixels_out.rushmeier pixels_out.rushmeier > 252.eon.rushmeier.cmp']
-    ref_input_set = ['ref/input/chair.camera', 'ref/input/chair.control.cook', 'ref/input/chair.control.kajiya', 'ref/input/chair.control.rushmeier', 'ref/input/chair.surfaces', 'ref/input/eon.dat', 'ref/input/materials', 'ref/input/spectra.dat']
-    ref_output_set = ['ref/output/pixels_out.cook', 'ref/output/pixels_out.kajiya', 'ref/output/pixels_out.rushmeier']
-    ref_args = ['chair.control.cook chair.camera chair.surfaces chair.cook.ppm ppm pixels_out.cook > 252.eon.cook.out 2> 252.eon.cook.err', 'chair.control.kajiya chair.camera chair.surfaces chair.kajiya.ppm ppm pixels_out.kajiya > 252.eon.kajiya.out 2> 252.eon.kajiya.err', 'chair.control.rushmeier chair.camera chair.surfaces chair.rushmeier.ppm ppm pixels_out.rushmeier > 252.eon.rushmeier.out 2> 252.eon.rushmeier.err']
-    ref_cmp_cmds = ['fpcmp -a 0.005 pixels_out.cook pixels_out.cook > 252.eon.cook.cmp', 'fpcmp -a 0.005 pixels_out.kajiya pixels_out.kajiya > 252.eon.kajiya.cmp', 'fpcmp -a 0.005 pixels_out.rushmeier pixels_out.rushmeier > 252.eon.rushmeier.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "252.eon"
+
+    train_input_set = [
+        "train/input/chair.camera",
+        "train/input/chair.control.cook",
+        "train/input/chair.control.kajiya",
+        "train/input/chair.control.rushmeier",
+        "train/input/chair.surfaces",
+        "train/input/eon.dat",
+        "train/input/materials",
+        "train/input/spectra.dat",
+    ]
+    train_output_set = [
+        "train/output/pixels_out.cook",
+        "train/output/pixels_out.kajiya",
+        "train/output/pixels_out.rushmeier",
+    ]
+    train_args = [
+        "chair.control.cook chair.camera chair.surfaces chair.cook.ppm ppm pixels_out.cook > 252.eon.cook.out 2> 252.eon.cook.err",
+        "chair.control.kajiya chair.camera chair.surfaces chair.kajiya.ppm ppm pixels_out.kajiya > 252.eon.kajiya.out 2> 252.eon.kajiya.err",
+        "chair.control.rushmeier chair.camera chair.surfaces chair.rushmeier.ppm ppm pixels_out.rushmeier > 252.eon.rushmeier.out 2> 252.eon.rushmeier.err",
+    ]
+    train_cmp_cmds = [
+        "fpcmp -a 0.005 pixels_out.cook pixels_out.cook > 252.eon.cook.cmp",
+        "fpcmp -a 0.005 pixels_out.kajiya pixels_out.kajiya > 252.eon.kajiya.cmp",
+        "fpcmp -a 0.005 pixels_out.rushmeier pixels_out.rushmeier > 252.eon.rushmeier.cmp",
+    ]
+    ref_input_set = [
+        "ref/input/chair.camera",
+        "ref/input/chair.control.cook",
+        "ref/input/chair.control.kajiya",
+        "ref/input/chair.control.rushmeier",
+        "ref/input/chair.surfaces",
+        "ref/input/eon.dat",
+        "ref/input/materials",
+        "ref/input/spectra.dat",
+    ]
+    ref_output_set = [
+        "ref/output/pixels_out.cook",
+        "ref/output/pixels_out.kajiya",
+        "ref/output/pixels_out.rushmeier",
+    ]
+    ref_args = [
+        "chair.control.cook chair.camera chair.surfaces chair.cook.ppm ppm pixels_out.cook > 252.eon.cook.out 2> 252.eon.cook.err",
+        "chair.control.kajiya chair.camera chair.surfaces chair.kajiya.ppm ppm pixels_out.kajiya > 252.eon.kajiya.out 2> 252.eon.kajiya.err",
+        "chair.control.rushmeier chair.camera chair.surfaces chair.rushmeier.ppm ppm pixels_out.rushmeier > 252.eon.rushmeier.out 2> 252.eon.rushmeier.err",
+    ]
+    ref_cmp_cmds = [
+        "fpcmp -a 0.005 pixels_out.cook pixels_out.cook > 252.eon.cook.cmp",
+        "fpcmp -a 0.005 pixels_out.kajiya pixels_out.kajiya > 252.eon.kajiya.cmp",
+        "fpcmp -a 0.005 pixels_out.rushmeier pixels_out.rushmeier > 252.eon.rushmeier.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_252_eon
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/253.perlbmk/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_253_perlbmk(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '253.perlbmk'
-
-    train_input_set = ['all/input/cpu2000_mhonarc.rc', 'all/input/lib', 'all/input/lenums', 'all/input/benums', 'train/input/dictionary', 'all/input/diffmail.pl', 'all/input/perfect.pl', 'train/input/scrabbl.pl', 'train/input/scrabbl.in']
-    train_output_set = ['train/output/2.350.15.24.23.150.out', 'train/output/b.3.out', 'train/output/scrabbl.out']
-    train_args = ['-Ilib diffmail.pl 2 350 15 24 23 150 > 253.perlbmk.diffmail.out 2> 253.perlbmk.diffmail.err', '-Ilib perfect.pl b 3 > 253.perlbmk.perfect.out 2> 253.perlbmk.perfect.err', '-Ilib scrabbl.pl < scrabbl.in > 253.perlbmk.scrabbl.out 2> 253.perlbmk.scrabbl.err']
-    train_cmp_cmds = ['diff 253.perlbmk.diffmail.out 2.350.15.24.23.150.out --strip-trailing-cr > 253.perlbmk.diffmail.cmp', 'diff 253.perlbmk.perfect.out b.3.out --strip-trailing-cr > 253.perlbmk.perfect.cmp', 'diff 253.perlbmk.scrabbl.out scrabbl.out --strip-trailing-cr > 253.perlbmk.scrabbl.cmp']
-    ref_input_set = ['all/input/cpu2000_mhonarc.rc', 'all/input/lib', 'all/input/lenums', 'all/input/benums', 'all/input/diffmail.pl', 'ref/input/makerand.pl', 'all/input/perfect.pl', 'ref/input/splitmail.pl']
-    ref_output_set = ['ref/output/2.550.15.24.23.100.out', 'ref/output/makerand.out', 'ref/output/b.3.m.4.out', 'ref/output/850.5.19.18.1500.out', 'ref/output/704.12.26.16.836.out', 'ref/output/535.13.25.24.1091.out', 'ref/output/957.12.23.26.1014.out']
-    ref_args = ['-Ilib diffmail.pl 2 550 15 24 23 100 > 253.perlbmk.diffmail.out 2> 253.perlbmk.diffmail.err', '-Ilib makerand.pl > 253.perlbmk.makerand.out 2> 253.perlbmk.makerand.err', '-Ilib perfect.pl b 3 m 4 > 253.perlbmk.perfect.out 2> 253.perlbmk.perfect.err', '-Ilib splitmail.pl 850 5 19 18 1500 > 253.perlbmk.splitmail1.out 2> 253.perlbmk.splitmail1.err', '-Ilib splitmail.pl 704 12 26 16 836 > 253.perlbmk.splitmail2.out 2> 253.perlbmk.splitmail2.err', '-Ilib splitmail.pl 535 13 25 24 1091 > 253.perlbmk.splitmail3.out 2> 253.perlbmk.splitmail3.err', '-Ilib splitmail.pl 957 12 23 26 1014 > 253.perlbmk.splitmail4.out 2> 253.perlbmk.splitmail4.err']
-    ref_cmp_cmds = ['diff 253.perlbmk.diffmail.out 2.550.15.24.23.100.out --strip-trailing-cr > 253.perlbmk.diffmail.cmp', 'diff 253.perlbmk.makerand.out makerand.out --strip-trailing-cr > 253.perlbmk.makerand.cmp', 'diff 253.perlbmk.perfect.out b.3.m.4.out --strip-trailing-cr > 253.perlbmk.perfect.cmp', 'diff 253.perlbmk.splitmail1.out 850.5.19.18.1500.out --strip-trailing-cr > 253.perlbmk.splitmail1.cmp', 'diff 253.perlbmk.splitmail2.out 704.12.26.16.836.out --strip-trailing-cr > 253.perlbmk.splitmail2.cmp', 'diff 253.perlbmk.splitmail3.out 535.13.25.24.1091.out --strip-trailing-cr > 253.perlbmk.splitmail3.cmp', 'diff 253.perlbmk.splitmail4.out 957.12.23.26.1014.out --strip-trailing-cr > 253.perlbmk.splitmail4.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "253.perlbmk"
+
+    train_input_set = [
+        "all/input/cpu2000_mhonarc.rc",
+        "all/input/lib",
+        "all/input/lenums",
+        "all/input/benums",
+        "train/input/dictionary",
+        "all/input/diffmail.pl",
+        "all/input/perfect.pl",
+        "train/input/scrabbl.pl",
+        "train/input/scrabbl.in",
+    ]
+    train_output_set = [
+        "train/output/2.350.15.24.23.150.out",
+        "train/output/b.3.out",
+        "train/output/scrabbl.out",
+    ]
+    train_args = [
+        "-Ilib diffmail.pl 2 350 15 24 23 150 > 253.perlbmk.diffmail.out 2> 253.perlbmk.diffmail.err",
+        "-Ilib perfect.pl b 3 > 253.perlbmk.perfect.out 2> 253.perlbmk.perfect.err",
+        "-Ilib scrabbl.pl < scrabbl.in > 253.perlbmk.scrabbl.out 2> 253.perlbmk.scrabbl.err",
+    ]
+    train_cmp_cmds = [
+        "diff 253.perlbmk.diffmail.out 2.350.15.24.23.150.out --strip-trailing-cr > 253.perlbmk.diffmail.cmp",
+        "diff 253.perlbmk.perfect.out b.3.out --strip-trailing-cr > 253.perlbmk.perfect.cmp",
+        "diff 253.perlbmk.scrabbl.out scrabbl.out --strip-trailing-cr > 253.perlbmk.scrabbl.cmp",
+    ]
+    ref_input_set = [
+        "all/input/cpu2000_mhonarc.rc",
+        "all/input/lib",
+        "all/input/lenums",
+        "all/input/benums",
+        "all/input/diffmail.pl",
+        "ref/input/makerand.pl",
+        "all/input/perfect.pl",
+        "ref/input/splitmail.pl",
+    ]
+    ref_output_set = [
+        "ref/output/2.550.15.24.23.100.out",
+        "ref/output/makerand.out",
+        "ref/output/b.3.m.4.out",
+        "ref/output/850.5.19.18.1500.out",
+        "ref/output/704.12.26.16.836.out",
+        "ref/output/535.13.25.24.1091.out",
+        "ref/output/957.12.23.26.1014.out",
+    ]
+    ref_args = [
+        "-Ilib diffmail.pl 2 550 15 24 23 100 > 253.perlbmk.diffmail.out 2> 253.perlbmk.diffmail.err",
+        "-Ilib makerand.pl > 253.perlbmk.makerand.out 2> 253.perlbmk.makerand.err",
+        "-Ilib perfect.pl b 3 m 4 > 253.perlbmk.perfect.out 2> 253.perlbmk.perfect.err",
+        "-Ilib splitmail.pl 850 5 19 18 1500 > 253.perlbmk.splitmail1.out 2> 253.perlbmk.splitmail1.err",
+        "-Ilib splitmail.pl 704 12 26 16 836 > 253.perlbmk.splitmail2.out 2> 253.perlbmk.splitmail2.err",
+        "-Ilib splitmail.pl 535 13 25 24 1091 > 253.perlbmk.splitmail3.out 2> 253.perlbmk.splitmail3.err",
+        "-Ilib splitmail.pl 957 12 23 26 1014 > 253.perlbmk.splitmail4.out 2> 253.perlbmk.splitmail4.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 253.perlbmk.diffmail.out 2.550.15.24.23.100.out --strip-trailing-cr > 253.perlbmk.diffmail.cmp",
+        "diff 253.perlbmk.makerand.out makerand.out --strip-trailing-cr > 253.perlbmk.makerand.cmp",
+        "diff 253.perlbmk.perfect.out b.3.m.4.out --strip-trailing-cr > 253.perlbmk.perfect.cmp",
+        "diff 253.perlbmk.splitmail1.out 850.5.19.18.1500.out --strip-trailing-cr > 253.perlbmk.splitmail1.cmp",
+        "diff 253.perlbmk.splitmail2.out 704.12.26.16.836.out --strip-trailing-cr > 253.perlbmk.splitmail2.cmp",
+        "diff 253.perlbmk.splitmail3.out 535.13.25.24.1091.out --strip-trailing-cr > 253.perlbmk.splitmail3.cmp",
+        "diff 253.perlbmk.splitmail4.out 957.12.23.26.1014.out --strip-trailing-cr > 253.perlbmk.splitmail4.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_253_perlbmk
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/254.gap/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_254_gap(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '254.gap'
-
-    train_input_set = ['all/input/abattoir.g', 'all/input/agcoset.g', 'all/input/aghomomo.g', 'all/input/agsubgrp.g', 'all/input/algfld.g', 'all/input/basic.grp', 'all/input/combinat.g', 'all/input/ctfilter.g', 'all/input/ctmapcon.g', 'all/input/ctsymmet.g', 'all/input/field.g', 'all/input/fptietze.g', 'all/input/grpcoset.g', 'all/input/grplatt.g', 'all/input/lattperf.g', 'all/input/matgrp.grp', 'all/input/monomial.g', 'all/input/onecohom.g', 'all/input/permcose.g', 'all/input/permhomo.g', 'all/input/permstbc.g', 'all/input/polynom.g', 'all/input/ratclass.g', 'all/input/rowspace.g', 'all/input/sqstuff.g', 'all/input/agcent.g', 'all/input/agctbl.g', 'all/input/aginters.g', 'all/input/agwords.g', 'all/input/algfp.g', 'all/input/cdaggrp.g', 'all/input/ctautoms.g', 'all/input/ctgapmoc.g', 'all/input/ctmapusi.g', 'all/input/cyclotom.g', 'all/input/finfield.g', 'all/input/galois.g', 'all/input/grpctbl.g', 'all/input/grpprods.g', 'all/input/list.g', 'all/input/matring.g', 'all/input/morpheus.g', 'all/input/operatio.g', 'all/input/permcser.g', 'all/input/permnorm.g', 'all/input/permutat.g', 'all/input/polyrat.g', 'all/input/rational.g', 'all/input/saggroup.g', 'all/input/string.g', 'all/input/agclass.g', 'all/input/aggroup.g', 'all/input/agnorm.g', 'all/input/algebra.g', 'all/input/alghomom.g', 'all/input/chartabl.g', 'all/input/ctbasic.g', 'all/input/ctgeneri.g', 'all/input/ctpermch.g', 'all/input/dispatch.g', 'all/input/fpgrp.g', 'all/input/gaussian.g', 'all/input/grpelms.g', 'all/input/init.g', 'all/input/mapping.g', 'all/input/matrix.g', 'all/input/numfield.g', 'all/input/permag.g', 'all/input/permctbl.g', 'all/input/permoper.g', 'all/input/polyfin.g', 'all/input/polystff.g', 'all/input/ring.g', 'all/input/sagsbgrp.g', 'all/input/tom.g', 'all/input/agcomple.g', 'all/input/aghall.g', 'all/input/agprops.g', 'all/input/algfac.g', 'all/input/algmat.g', 'all/input/classfun.g', 'all/input/ctcharac.g', 'all/input/ctlattic.g', 'all/input/ctpgrp.g', 'all/input/domain.g', 'all/input/fpsgpres.g', 'all/input/group.g', 'all/input/grphomom.g', 'all/input/integer.g', 'all/input/matgrp.g', 'all/input/module.g', 'all/input/numtheor.g', 'all/input/permbckt.g', 'all/input/permgrp.g', 'all/input/permprod.g', 'all/input/polyfld.g', 'all/input/pq.g', 'all/input/rowmodul.g', 'all/input/sq.g', 'all/input/vecspace.g', 'train/input/train.in']
-    train_output_set = ['train/output/train.out']
-    train_args = ['< train.in -l ./ -q -m 128M > 254.gap.train.out 2> 254.gap.train.err']
-    train_cmp_cmds = ['diff 254.gap.train.out train.out --strip-trailing-cr > 254.gap.train.cmp']
-    ref_input_set = ['all/input/abattoir.g', 'all/input/agcoset.g', 'all/input/aghomomo.g', 'all/input/agsubgrp.g', 'all/input/algfld.g', 'all/input/basic.grp', 'all/input/combinat.g', 'all/input/ctfilter.g', 'all/input/ctmapcon.g', 'all/input/ctsymmet.g', 'all/input/field.g', 'all/input/fptietze.g', 'all/input/grpcoset.g', 'all/input/grplatt.g', 'all/input/lattperf.g', 'all/input/matgrp.grp', 'all/input/monomial.g', 'all/input/onecohom.g', 'all/input/permcose.g', 'all/input/permhomo.g', 'all/input/permstbc.g', 'all/input/polynom.g', 'all/input/ratclass.g', 'all/input/rowspace.g', 'all/input/sqstuff.g', 'all/input/agcent.g', 'all/input/agctbl.g', 'all/input/aginters.g', 'all/input/agwords.g', 'all/input/algfp.g', 'all/input/cdaggrp.g', 'all/input/ctautoms.g', 'all/input/ctgapmoc.g', 'all/input/ctmapusi.g', 'all/input/cyclotom.g', 'all/input/finfield.g', 'all/input/galois.g', 'all/input/grpctbl.g', 'all/input/grpprods.g', 'all/input/list.g', 'all/input/matring.g', 'all/input/morpheus.g', 'all/input/operatio.g', 'all/input/permcser.g', 'all/input/permnorm.g', 'all/input/permutat.g', 'all/input/polyrat.g', 'all/input/rational.g', 'all/input/saggroup.g', 'all/input/string.g', 'all/input/agclass.g', 'all/input/aggroup.g', 'all/input/agnorm.g', 'all/input/algebra.g', 'all/input/alghomom.g', 'all/input/chartabl.g', 'all/input/ctbasic.g', 'all/input/ctgeneri.g', 'all/input/ctpermch.g', 'all/input/dispatch.g', 'all/input/fpgrp.g', 'all/input/gaussian.g', 'all/input/grpelms.g', 'all/input/init.g', 'all/input/mapping.g', 'all/input/matrix.g', 'all/input/numfield.g', 'all/input/permag.g', 'all/input/permctbl.g', 'all/input/permoper.g', 'all/input/polyfin.g', 'all/input/polystff.g', 'all/input/ring.g', 'all/input/sagsbgrp.g', 'all/input/tom.g', 'all/input/agcomple.g', 'all/input/aghall.g', 'all/input/agprops.g', 'all/input/algfac.g', 'all/input/algmat.g', 'all/input/classfun.g', 'all/input/ctcharac.g', 'all/input/ctlattic.g', 'all/input/ctpgrp.g', 'all/input/domain.g', 'all/input/fpsgpres.g', 'all/input/group.g', 'all/input/grphomom.g', 'all/input/integer.g', 'all/input/matgrp.g', 'all/input/module.g', 'all/input/numtheor.g', 'all/input/permbckt.g', 'all/input/permgrp.g', 'all/input/permprod.g', 'all/input/polyfld.g', 'all/input/pq.g', 'all/input/rowmodul.g', 'all/input/sq.g', 'all/input/vecspace.g', 'ref/input/ref.in']
-    ref_output_set = ['ref/output/ref.out']
-    ref_args = ['< ref.in -l ./ -q -m 192M > 254.gap.ref.out 2> 254.gap.ref.err']
-    ref_cmp_cmds = ['diff 254.gap.ref.out ref.out --strip-trailing-cr > 254.gap.ref.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "254.gap"
+
+    train_input_set = [
+        "all/input/abattoir.g",
+        "all/input/agcoset.g",
+        "all/input/aghomomo.g",
+        "all/input/agsubgrp.g",
+        "all/input/algfld.g",
+        "all/input/basic.grp",
+        "all/input/combinat.g",
+        "all/input/ctfilter.g",
+        "all/input/ctmapcon.g",
+        "all/input/ctsymmet.g",
+        "all/input/field.g",
+        "all/input/fptietze.g",
+        "all/input/grpcoset.g",
+        "all/input/grplatt.g",
+        "all/input/lattperf.g",
+        "all/input/matgrp.grp",
+        "all/input/monomial.g",
+        "all/input/onecohom.g",
+        "all/input/permcose.g",
+        "all/input/permhomo.g",
+        "all/input/permstbc.g",
+        "all/input/polynom.g",
+        "all/input/ratclass.g",
+        "all/input/rowspace.g",
+        "all/input/sqstuff.g",
+        "all/input/agcent.g",
+        "all/input/agctbl.g",
+        "all/input/aginters.g",
+        "all/input/agwords.g",
+        "all/input/algfp.g",
+        "all/input/cdaggrp.g",
+        "all/input/ctautoms.g",
+        "all/input/ctgapmoc.g",
+        "all/input/ctmapusi.g",
+        "all/input/cyclotom.g",
+        "all/input/finfield.g",
+        "all/input/galois.g",
+        "all/input/grpctbl.g",
+        "all/input/grpprods.g",
+        "all/input/list.g",
+        "all/input/matring.g",
+        "all/input/morpheus.g",
+        "all/input/operatio.g",
+        "all/input/permcser.g",
+        "all/input/permnorm.g",
+        "all/input/permutat.g",
+        "all/input/polyrat.g",
+        "all/input/rational.g",
+        "all/input/saggroup.g",
+        "all/input/string.g",
+        "all/input/agclass.g",
+        "all/input/aggroup.g",
+        "all/input/agnorm.g",
+        "all/input/algebra.g",
+        "all/input/alghomom.g",
+        "all/input/chartabl.g",
+        "all/input/ctbasic.g",
+        "all/input/ctgeneri.g",
+        "all/input/ctpermch.g",
+        "all/input/dispatch.g",
+        "all/input/fpgrp.g",
+        "all/input/gaussian.g",
+        "all/input/grpelms.g",
+        "all/input/init.g",
+        "all/input/mapping.g",
+        "all/input/matrix.g",
+        "all/input/numfield.g",
+        "all/input/permag.g",
+        "all/input/permctbl.g",
+        "all/input/permoper.g",
+        "all/input/polyfin.g",
+        "all/input/polystff.g",
+        "all/input/ring.g",
+        "all/input/sagsbgrp.g",
+        "all/input/tom.g",
+        "all/input/agcomple.g",
+        "all/input/aghall.g",
+        "all/input/agprops.g",
+        "all/input/algfac.g",
+        "all/input/algmat.g",
+        "all/input/classfun.g",
+        "all/input/ctcharac.g",
+        "all/input/ctlattic.g",
+        "all/input/ctpgrp.g",
+        "all/input/domain.g",
+        "all/input/fpsgpres.g",
+        "all/input/group.g",
+        "all/input/grphomom.g",
+        "all/input/integer.g",
+        "all/input/matgrp.g",
+        "all/input/module.g",
+        "all/input/numtheor.g",
+        "all/input/permbckt.g",
+        "all/input/permgrp.g",
+        "all/input/permprod.g",
+        "all/input/polyfld.g",
+        "all/input/pq.g",
+        "all/input/rowmodul.g",
+        "all/input/sq.g",
+        "all/input/vecspace.g",
+        "train/input/train.in",
+    ]
+    train_output_set = ["train/output/train.out"]
+    train_args = [
+        "< train.in -l ./ -q -m 128M > 254.gap.train.out 2> 254.gap.train.err"
+    ]
+    train_cmp_cmds = [
+        "diff 254.gap.train.out train.out --strip-trailing-cr > 254.gap.train.cmp"
+    ]
+    ref_input_set = [
+        "all/input/abattoir.g",
+        "all/input/agcoset.g",
+        "all/input/aghomomo.g",
+        "all/input/agsubgrp.g",
+        "all/input/algfld.g",
+        "all/input/basic.grp",
+        "all/input/combinat.g",
+        "all/input/ctfilter.g",
+        "all/input/ctmapcon.g",
+        "all/input/ctsymmet.g",
+        "all/input/field.g",
+        "all/input/fptietze.g",
+        "all/input/grpcoset.g",
+        "all/input/grplatt.g",
+        "all/input/lattperf.g",
+        "all/input/matgrp.grp",
+        "all/input/monomial.g",
+        "all/input/onecohom.g",
+        "all/input/permcose.g",
+        "all/input/permhomo.g",
+        "all/input/permstbc.g",
+        "all/input/polynom.g",
+        "all/input/ratclass.g",
+        "all/input/rowspace.g",
+        "all/input/sqstuff.g",
+        "all/input/agcent.g",
+        "all/input/agctbl.g",
+        "all/input/aginters.g",
+        "all/input/agwords.g",
+        "all/input/algfp.g",
+        "all/input/cdaggrp.g",
+        "all/input/ctautoms.g",
+        "all/input/ctgapmoc.g",
+        "all/input/ctmapusi.g",
+        "all/input/cyclotom.g",
+        "all/input/finfield.g",
+        "all/input/galois.g",
+        "all/input/grpctbl.g",
+        "all/input/grpprods.g",
+        "all/input/list.g",
+        "all/input/matring.g",
+        "all/input/morpheus.g",
+        "all/input/operatio.g",
+        "all/input/permcser.g",
+        "all/input/permnorm.g",
+        "all/input/permutat.g",
+        "all/input/polyrat.g",
+        "all/input/rational.g",
+        "all/input/saggroup.g",
+        "all/input/string.g",
+        "all/input/agclass.g",
+        "all/input/aggroup.g",
+        "all/input/agnorm.g",
+        "all/input/algebra.g",
+        "all/input/alghomom.g",
+        "all/input/chartabl.g",
+        "all/input/ctbasic.g",
+        "all/input/ctgeneri.g",
+        "all/input/ctpermch.g",
+        "all/input/dispatch.g",
+        "all/input/fpgrp.g",
+        "all/input/gaussian.g",
+        "all/input/grpelms.g",
+        "all/input/init.g",
+        "all/input/mapping.g",
+        "all/input/matrix.g",
+        "all/input/numfield.g",
+        "all/input/permag.g",
+        "all/input/permctbl.g",
+        "all/input/permoper.g",
+        "all/input/polyfin.g",
+        "all/input/polystff.g",
+        "all/input/ring.g",
+        "all/input/sagsbgrp.g",
+        "all/input/tom.g",
+        "all/input/agcomple.g",
+        "all/input/aghall.g",
+        "all/input/agprops.g",
+        "all/input/algfac.g",
+        "all/input/algmat.g",
+        "all/input/classfun.g",
+        "all/input/ctcharac.g",
+        "all/input/ctlattic.g",
+        "all/input/ctpgrp.g",
+        "all/input/domain.g",
+        "all/input/fpsgpres.g",
+        "all/input/group.g",
+        "all/input/grphomom.g",
+        "all/input/integer.g",
+        "all/input/matgrp.g",
+        "all/input/module.g",
+        "all/input/numtheor.g",
+        "all/input/permbckt.g",
+        "all/input/permgrp.g",
+        "all/input/permprod.g",
+        "all/input/polyfld.g",
+        "all/input/pq.g",
+        "all/input/rowmodul.g",
+        "all/input/sq.g",
+        "all/input/vecspace.g",
+        "ref/input/ref.in",
+    ]
+    ref_output_set = ["ref/output/ref.out"]
+    ref_args = ["< ref.in -l ./ -q -m 192M > 254.gap.ref.out 2> 254.gap.ref.err"]
+    ref_cmp_cmds = [
+        "diff 254.gap.ref.out ref.out --strip-trailing-cr > 254.gap.ref.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_254_gap
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/255.vortex/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import os, shutil
 import spec
 
+
 class SPEC2000_255_vortex(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '255.vortex'
-
-    train_input_set = ['train/input/lendian.rnv', 'train/input/lendian.wnv', 'train/input/persons.250', 'train/input/lendian.raw']
-    train_output_set = ['train/output/vortex.out']
-    train_args = ['lendian.raw > 255.vortex.lendian.out 2> 255.vortex.lendian.err']
-    train_cmp_cmds = ['diff vortex.out-expected vortex.out > 255.vortex.lendian.cmp']
-    ref_input_set = ['ref/input/lendian.rnv', 'ref/input/lendian.wnv', 'ref/input/persons.1k', 'ref/input/lendian1.raw', 'ref/input/lendian2.raw', 'ref/input/lendian3.raw']
-    ref_output_set = ['ref/output/vortex1.out', 'ref/output/vortex2.out', 'ref/output/vortex3.out']
-    ref_args = ['lendian1.raw > 255.vortex.lendian1.out 2> 255.vortex.lendian1.err', 'lendian2.raw > 255.vortex.lendian2.out 2> 255.vortex.lendian2.err', 'lendian3.raw > 255.vortex.lendian3.out 2> 255.vortex.lendian3.err']
-    ref_cmp_cmds = ['diff vortex1.out.expected vortex1.out > 255.vortex.lendian1.cmp',
-                    'diff vortex2.out.expected vortex2.out > 255.vortex.lendian2.cmp',
-                    'diff vortex3.out.expected vortex3.out > 255.vortex.lendian3.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "255.vortex"
+
+    train_input_set = [
+        "train/input/lendian.rnv",
+        "train/input/lendian.wnv",
+        "train/input/persons.250",
+        "train/input/lendian.raw",
+    ]
+    train_output_set = ["train/output/vortex.out"]
+    train_args = ["lendian.raw > 255.vortex.lendian.out 2> 255.vortex.lendian.err"]
+    train_cmp_cmds = ["diff vortex.out-expected vortex.out > 255.vortex.lendian.cmp"]
+    ref_input_set = [
+        "ref/input/lendian.rnv",
+        "ref/input/lendian.wnv",
+        "ref/input/persons.1k",
+        "ref/input/lendian1.raw",
+        "ref/input/lendian2.raw",
+        "ref/input/lendian3.raw",
+    ]
+    ref_output_set = [
+        "ref/output/vortex1.out",
+        "ref/output/vortex2.out",
+        "ref/output/vortex3.out",
+    ]
+    ref_args = [
+        "lendian1.raw > 255.vortex.lendian1.out 2> 255.vortex.lendian1.err",
+        "lendian2.raw > 255.vortex.lendian2.out 2> 255.vortex.lendian2.err",
+        "lendian3.raw > 255.vortex.lendian3.out 2> 255.vortex.lendian3.err",
+    ]
+    ref_cmp_cmds = [
+        "diff vortex1.out.expected vortex1.out > 255.vortex.lendian1.cmp",
+        "diff vortex2.out.expected vortex2.out > 255.vortex.lendian2.cmp",
+        "diff vortex3.out.expected vortex3.out > 255.vortex.lendian3.cmp",
+    ]
 
     # We need to rename the files for the expected output because the test
     # generate its output under the same names.
     def copy_output_set(self, dest_dir, size):
-        if size == 'train':
+        if size == "train":
             output_set = self.train_output_set
         else:
             output_set = self.ref_output_set
 
         for f in output_set:
-            filename = os.path.basename(f) + '.expected'
+            filename = os.path.basename(f) + ".expected"
             shutil.copy(os.path.join(self.datadir, f), os.path.join(dest_dir, filename))
 
+
 # This is the only required entry point to the module.
 test_class = SPEC2000_255_vortex
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/256.bzip2/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_256_bzip2(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '256.bzip2'
-
-    train_input_set = ['train/input/input.compressed']
-    train_output_set = ['train/output/input.compressed.out']
-    train_args = ['input.compressed 8 > 256.bzip2.compressed.out 2> 256.bzip2.compressed.err']
-    train_cmp_cmds = ['diff 256.bzip2.compressed.out input.compressed.out --strip-trailing-cr > 256.bzip2.compressed.cmp']
-    ref_input_set = ['ref/input/input.graphic', 'ref/input/input.program', 'ref/input/input.source']
-    ref_output_set = ['ref/output/input.graphic.out', 'ref/output/input.program.out', 'ref/output/input.source.out']
-    ref_args = ['input.graphic 58 > 256.bzip2.graphic.out 2> 256.bzip2.graphic.err', 'input.program 58 > 256.bzip2.program.out 2> 256.bzip2.program.err', 'input.source 58 > 256.bzip2.source.out 2> 256.bzip2.source.err']
-    ref_cmp_cmds = ['diff 256.bzip2.graphic.out input.graphic.out --strip-trailing-cr > 256.bzip2.graphic.cmp', 'diff 256.bzip2.program.out input.program.out --strip-trailing-cr > 256.bzip2.program.cmp', 'diff 256.bzip2.source.out input.source.out --strip-trailing-cr > 256.bzip2.source.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "256.bzip2"
+
+    train_input_set = ["train/input/input.compressed"]
+    train_output_set = ["train/output/input.compressed.out"]
+    train_args = [
+        "input.compressed 8 > 256.bzip2.compressed.out 2> 256.bzip2.compressed.err"
+    ]
+    train_cmp_cmds = [
+        "diff 256.bzip2.compressed.out input.compressed.out --strip-trailing-cr > 256.bzip2.compressed.cmp"
+    ]
+    ref_input_set = [
+        "ref/input/input.graphic",
+        "ref/input/input.program",
+        "ref/input/input.source",
+    ]
+    ref_output_set = [
+        "ref/output/input.graphic.out",
+        "ref/output/input.program.out",
+        "ref/output/input.source.out",
+    ]
+    ref_args = [
+        "input.graphic 58 > 256.bzip2.graphic.out 2> 256.bzip2.graphic.err",
+        "input.program 58 > 256.bzip2.program.out 2> 256.bzip2.program.err",
+        "input.source 58 > 256.bzip2.source.out 2> 256.bzip2.source.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 256.bzip2.graphic.out input.graphic.out --strip-trailing-cr > 256.bzip2.graphic.cmp",
+        "diff 256.bzip2.program.out input.program.out --strip-trailing-cr > 256.bzip2.program.cmp",
+        "diff 256.bzip2.source.out input.source.out --strip-trailing-cr > 256.bzip2.source.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_256_bzip2
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2000/int/300.twolf/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2000_300_twolf(spec.TestModule):
-    year = '2000'
-    category = 'int'
-    benchmark = '300.twolf'
-
-    train_input_set = ['train/input/train.blk', 'train/input/train.cel', 'train/input/train.par', 'train/input/train.net']
-    train_output_set = ['train/output/train.stdout']
-    train_args = ['train > 300.twolf.train.out 2> 300.twolf.train.err']
-    train_cmp_cmds = ['diff 300.twolf.train.out train.stdout --strip-trailing-cr > 300.twolf.train.cmp']
-    ref_input_set = ['ref/input/ref.blk', 'ref/input/ref.cel', 'ref/input/ref.par', 'ref/input/ref.net']
-    ref_output_set = ['ref/output/ref.stdout']
-    ref_args = ['ref > 300.twolf.ref.out 2> 300.twolf.ref.err']
-    ref_cmp_cmds = ['diff 300.twolf.ref.out ref.stdout --strip-trailing-cr > 300.twolf.ref.cmp']
+    year = "2000"
+    category = "int"
+    benchmark = "300.twolf"
+
+    train_input_set = [
+        "train/input/train.blk",
+        "train/input/train.cel",
+        "train/input/train.par",
+        "train/input/train.net",
+    ]
+    train_output_set = ["train/output/train.stdout"]
+    train_args = ["train > 300.twolf.train.out 2> 300.twolf.train.err"]
+    train_cmp_cmds = [
+        "diff 300.twolf.train.out train.stdout --strip-trailing-cr > 300.twolf.train.cmp"
+    ]
+    ref_input_set = [
+        "ref/input/ref.blk",
+        "ref/input/ref.cel",
+        "ref/input/ref.par",
+        "ref/input/ref.net",
+    ]
+    ref_output_set = ["ref/output/ref.stdout"]
+    ref_args = ["ref > 300.twolf.ref.out 2> 300.twolf.ref.err"]
+    ref_cmp_cmds = [
+        "diff 300.twolf.ref.out ref.stdout --strip-trailing-cr > 300.twolf.ref.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2000_300_twolf
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/433.milc/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_433_milc(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '433.milc'
-
-    train_input_set = ['train/input/su3imp.in']
-    train_output_set = ['train/output/su3imp.out']
-    train_args = ['< su3imp.in > 433.milc.su3imp.out 2> 433.milc.su3imp.err']
-    train_cmp_cmds = ['fpcmp -r 0.0001 -a 0.0000002 433.milc.su3imp.out su3imp.out > 433.milc.su3imp.cmp']
-    ref_input_set = ['ref/input/su3imp.in']
-    ref_output_set = ['ref/output/su3imp.out']
-    ref_args = ['< su3imp.in > 433.milc.su3imp.out 2> 433.milc.su3imp.err']
-    ref_cmp_cmds = ['fpcmp -r 0.0001 -a 0.0000002 433.milc.su3imp.out su3imp.out > 433.milc.su3imp.cmp']
+    year = "2006"
+    category = "fp"
+    benchmark = "433.milc"
+
+    train_input_set = ["train/input/su3imp.in"]
+    train_output_set = ["train/output/su3imp.out"]
+    train_args = ["< su3imp.in > 433.milc.su3imp.out 2> 433.milc.su3imp.err"]
+    train_cmp_cmds = [
+        "fpcmp -r 0.0001 -a 0.0000002 433.milc.su3imp.out su3imp.out > 433.milc.su3imp.cmp"
+    ]
+    ref_input_set = ["ref/input/su3imp.in"]
+    ref_output_set = ["ref/output/su3imp.out"]
+    ref_args = ["< su3imp.in > 433.milc.su3imp.out 2> 433.milc.su3imp.err"]
+    ref_cmp_cmds = [
+        "fpcmp -r 0.0001 -a 0.0000002 433.milc.su3imp.out su3imp.out > 433.milc.su3imp.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_433_milc
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/444.namd/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_444_namd(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '444.namd'
-
-    train_input_set = ['all/input/namd.input']
-    train_output_set = ['train/output/namd.out']
-    train_args = ['--input namd.input --iterations 1 --output namd.out > 444.namd.namd.out 2> 444.namd.namd.err']
-    train_cmp_cmds = ['fpcmp -a 0.00001 namd.out namd.out > 444.namd.namd.cmp']
-    ref_input_set = ['all/input/namd.input']
-    ref_output_set = ['ref/output/namd.out']
-    ref_args = ['--input namd.input --iterations 38 --output namd.out > 444.namd.namd.out 2> 444.namd.namd.err']
-    ref_cmp_cmds = ['fpcmp -a 0.00001 namd.out namd.out > 444.namd.namd.cmp']
+    year = "2006"
+    category = "fp"
+    benchmark = "444.namd"
+
+    train_input_set = ["all/input/namd.input"]
+    train_output_set = ["train/output/namd.out"]
+    train_args = [
+        "--input namd.input --iterations 1 --output namd.out > 444.namd.namd.out 2> 444.namd.namd.err"
+    ]
+    train_cmp_cmds = ["fpcmp -a 0.00001 namd.out namd.out > 444.namd.namd.cmp"]
+    ref_input_set = ["all/input/namd.input"]
+    ref_output_set = ["ref/output/namd.out"]
+    ref_args = [
+        "--input namd.input --iterations 38 --output namd.out > 444.namd.namd.out 2> 444.namd.namd.err"
+    ]
+    ref_cmp_cmds = ["fpcmp -a 0.00001 namd.out namd.out > 444.namd.namd.cmp"]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_444_namd
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/447.dealII/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_447_dealII(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '447.dealII'
+    year = "2006"
+    category = "fp"
+    benchmark = "447.dealII"
 
     train_input_set = []
-    train_output_set = ['train/output/log']
-    train_args = ['10 > 447.dealII.10.out 2> 447.dealII.10.err']
-    train_cmp_cmds = ['fpcmp -a .0000001 447.dealII.10.out log > 447.dealII.10.cmp']
+    train_output_set = ["train/output/log"]
+    train_args = ["10 > 447.dealII.10.out 2> 447.dealII.10.err"]
+    train_cmp_cmds = ["fpcmp -a .0000001 447.dealII.10.out log > 447.dealII.10.cmp"]
     ref_input_set = []
-    ref_output_set = ['ref/output/log']
-    ref_args = ['23 > 447.dealII.23.out 2> 447.dealII.23.err']
-    ref_cmp_cmds = ['fpcmp -a .0000001 447.dealII.23.out log > 447.dealII.23.cmp']
+    ref_output_set = ["ref/output/log"]
+    ref_args = ["23 > 447.dealII.23.out 2> 447.dealII.23.err"]
+    ref_cmp_cmds = ["fpcmp -a .0000001 447.dealII.23.out log > 447.dealII.23.cmp"]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_447_dealII
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/450.soplex/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_450_soplex(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '450.soplex'
-
-    train_input_set = ['train/input/train.mps', 'train/input/pds-20.mps']
-    train_output_set = ['train/output/pds-20.mps.out', 'train/output/train.out']
-    train_args = ['-s1 -e -m5000 pds-20.mps > 450.soplex.pds-20.out 2> 450.soplex.pds-20.err', '-m1200 train.mps > 450.soplex.train.out 2> 450.soplex.train.err']
-    train_cmp_cmds = ['fpcmp -a 1.0e-5 -r 20 450.soplex.pds-20.out pds-20.mps.out > 450.soplex.pds-20.cmp', 'fpcmp -a 1.0e-5 -r 20 450.soplex.train.out train.out > 450.soplex.train.cmp']
-    ref_input_set = ['ref/input/ref.mps', 'ref/input/pds-50.mps']
-    ref_output_set = ['ref/output/pds-50.mps.out', 'ref/output/ref.out']
-    ref_args = ['-s1 -e -m45000 pds-50.mps > 450.soplex.pds-50.out 2> 450.soplex.pds-50.err', '-m3500 ref.mps > 450.soplex.ref.out 2> 450.soplex.ref.err']
-    ref_cmp_cmds = ['fpcmp -a 1.0e-5 -r 0.02 450.soplex.pds-50.out pds-50.mps.out > 450.soplex.pds-50.cmp', 'fpcmp -a 1.0e-5 -r 0.02 450.soplex.ref.out ref.out > 450.soplex.ref.cmp']
+    year = "2006"
+    category = "fp"
+    benchmark = "450.soplex"
+
+    train_input_set = ["train/input/train.mps", "train/input/pds-20.mps"]
+    train_output_set = ["train/output/pds-20.mps.out", "train/output/train.out"]
+    train_args = [
+        "-s1 -e -m5000 pds-20.mps > 450.soplex.pds-20.out 2> 450.soplex.pds-20.err",
+        "-m1200 train.mps > 450.soplex.train.out 2> 450.soplex.train.err",
+    ]
+    train_cmp_cmds = [
+        "fpcmp -a 1.0e-5 -r 20 450.soplex.pds-20.out pds-20.mps.out > 450.soplex.pds-20.cmp",
+        "fpcmp -a 1.0e-5 -r 20 450.soplex.train.out train.out > 450.soplex.train.cmp",
+    ]
+    ref_input_set = ["ref/input/ref.mps", "ref/input/pds-50.mps"]
+    ref_output_set = ["ref/output/pds-50.mps.out", "ref/output/ref.out"]
+    ref_args = [
+        "-s1 -e -m45000 pds-50.mps > 450.soplex.pds-50.out 2> 450.soplex.pds-50.err",
+        "-m3500 ref.mps > 450.soplex.ref.out 2> 450.soplex.ref.err",
+    ]
+    ref_cmp_cmds = [
+        "fpcmp -a 1.0e-5 -r 0.02 450.soplex.pds-50.out pds-50.mps.out > 450.soplex.pds-50.cmp",
+        "fpcmp -a 1.0e-5 -r 0.02 450.soplex.ref.out ref.out > 450.soplex.ref.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_450_soplex
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/453.povray/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_453_povray(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '453.povray'
-
-    train_input_set = ['train/input/SPEC-benchmark-train.pov', 'all/input/arrays.inc', 'all/input/consts.inc', 'all/input/debug.inc', 'all/input/glass.inc', 'all/input/logo.inc', 'all/input/povlogo.ttf', 'all/input/screen.inc', 'all/input/shapes_old.inc', 'all/input/stage1.inc', 'all/input/stdinc.inc', 'all/input/stones1.inc', 'all/input/sunpos.inc', 'all/input/transforms.inc', 'all/input/chars.inc', 'all/input/crystal.ttf', 'all/input/finish.inc', 'all/input/glass_old.inc', 'all/input/math.inc', 'all/input/rad_def.inc', 'all/input/shapes.inc', 'all/input/shapesq.inc', 'all/input/stars.inc', 'all/input/stoneold.inc', 'all/input/stones2.inc', 'all/input/textures.inc', 'all/input/woodmaps.inc', 'all/input/colors.inc', 'all/input/cyrvetic.ttf', 'all/input/functions.inc', 'all/input/golds.inc', 'all/input/metals.inc', 'all/input/rand.inc', 'all/input/shapes2.inc', 'all/input/skies.inc', 'all/input/stdcam.inc', 'all/input/stones.inc', 'all/input/strings.inc', 'all/input/timrom.ttf', 'all/input/woods.inc', 'train/input/SPEC-benchmark-train.ini']
-    train_output_set = ['train/output/SPEC-benchmark.log']
-    train_args = ['SPEC-benchmark-train.ini > 453.povray.train.out 2> 453.povray.train.err']
-    train_cmp_cmds = ['diff SPEC-benchmark.log SPEC-benchmark.log > 453.povray.train.cmp']
-    ref_input_set = ['ref/input/SPEC-benchmark-ref.pov', 'all/input/arrays.inc', 'all/input/consts.inc', 'all/input/debug.inc', 'all/input/glass.inc', 'all/input/logo.inc', 'all/input/povlogo.ttf', 'all/input/screen.inc', 'all/input/shapes_old.inc', 'all/input/stage1.inc', 'all/input/stdinc.inc', 'all/input/stones1.inc', 'all/input/sunpos.inc', 'all/input/transforms.inc', 'all/input/chars.inc', 'all/input/crystal.ttf', 'all/input/finish.inc', 'all/input/glass_old.inc', 'all/input/math.inc', 'all/input/rad_def.inc', 'all/input/shapes.inc', 'all/input/shapesq.inc', 'all/input/stars.inc', 'all/input/stoneold.inc', 'all/input/stones2.inc', 'all/input/textures.inc', 'all/input/woodmaps.inc', 'all/input/colors.inc', 'all/input/cyrvetic.ttf', 'all/input/functions.inc', 'all/input/golds.inc', 'all/input/metals.inc', 'all/input/rand.inc', 'all/input/shapes2.inc', 'all/input/skies.inc', 'all/input/stdcam.inc', 'all/input/stones.inc', 'all/input/strings.inc', 'all/input/timrom.ttf', 'all/input/woods.inc', 'ref/input/SPEC-benchmark-ref.ini']
-    ref_output_set = ['ref/output/SPEC-benchmark.log']
-    ref_args = ['SPEC-benchmark-ref.ini > 453.povray.ref.out 2> 453.povray.ref.err']
-    ref_cmp_cmds = ['diff SPEC-benchmark.log SPEC-benchmark.log > 453.povray.ref.cmp']
+    year = "2006"
+    category = "fp"
+    benchmark = "453.povray"
+
+    train_input_set = [
+        "train/input/SPEC-benchmark-train.pov",
+        "all/input/arrays.inc",
+        "all/input/consts.inc",
+        "all/input/debug.inc",
+        "all/input/glass.inc",
+        "all/input/logo.inc",
+        "all/input/povlogo.ttf",
+        "all/input/screen.inc",
+        "all/input/shapes_old.inc",
+        "all/input/stage1.inc",
+        "all/input/stdinc.inc",
+        "all/input/stones1.inc",
+        "all/input/sunpos.inc",
+        "all/input/transforms.inc",
+        "all/input/chars.inc",
+        "all/input/crystal.ttf",
+        "all/input/finish.inc",
+        "all/input/glass_old.inc",
+        "all/input/math.inc",
+        "all/input/rad_def.inc",
+        "all/input/shapes.inc",
+        "all/input/shapesq.inc",
+        "all/input/stars.inc",
+        "all/input/stoneold.inc",
+        "all/input/stones2.inc",
+        "all/input/textures.inc",
+        "all/input/woodmaps.inc",
+        "all/input/colors.inc",
+        "all/input/cyrvetic.ttf",
+        "all/input/functions.inc",
+        "all/input/golds.inc",
+        "all/input/metals.inc",
+        "all/input/rand.inc",
+        "all/input/shapes2.inc",
+        "all/input/skies.inc",
+        "all/input/stdcam.inc",
+        "all/input/stones.inc",
+        "all/input/strings.inc",
+        "all/input/timrom.ttf",
+        "all/input/woods.inc",
+        "train/input/SPEC-benchmark-train.ini",
+    ]
+    train_output_set = ["train/output/SPEC-benchmark.log"]
+    train_args = [
+        "SPEC-benchmark-train.ini > 453.povray.train.out 2> 453.povray.train.err"
+    ]
+    train_cmp_cmds = [
+        "diff SPEC-benchmark.log SPEC-benchmark.log > 453.povray.train.cmp"
+    ]
+    ref_input_set = [
+        "ref/input/SPEC-benchmark-ref.pov",
+        "all/input/arrays.inc",
+        "all/input/consts.inc",
+        "all/input/debug.inc",
+        "all/input/glass.inc",
+        "all/input/logo.inc",
+        "all/input/povlogo.ttf",
+        "all/input/screen.inc",
+        "all/input/shapes_old.inc",
+        "all/input/stage1.inc",
+        "all/input/stdinc.inc",
+        "all/input/stones1.inc",
+        "all/input/sunpos.inc",
+        "all/input/transforms.inc",
+        "all/input/chars.inc",
+        "all/input/crystal.ttf",
+        "all/input/finish.inc",
+        "all/input/glass_old.inc",
+        "all/input/math.inc",
+        "all/input/rad_def.inc",
+        "all/input/shapes.inc",
+        "all/input/shapesq.inc",
+        "all/input/stars.inc",
+        "all/input/stoneold.inc",
+        "all/input/stones2.inc",
+        "all/input/textures.inc",
+        "all/input/woodmaps.inc",
+        "all/input/colors.inc",
+        "all/input/cyrvetic.ttf",
+        "all/input/functions.inc",
+        "all/input/golds.inc",
+        "all/input/metals.inc",
+        "all/input/rand.inc",
+        "all/input/shapes2.inc",
+        "all/input/skies.inc",
+        "all/input/stdcam.inc",
+        "all/input/stones.inc",
+        "all/input/strings.inc",
+        "all/input/timrom.ttf",
+        "all/input/woods.inc",
+        "ref/input/SPEC-benchmark-ref.ini",
+    ]
+    ref_output_set = ["ref/output/SPEC-benchmark.log"]
+    ref_args = ["SPEC-benchmark-ref.ini > 453.povray.ref.out 2> 453.povray.ref.err"]
+    ref_cmp_cmds = ["diff SPEC-benchmark.log SPEC-benchmark.log > 453.povray.ref.cmp"]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_453_povray
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/470.lbm/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_470_lbm(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '470.lbm'
-
-    train_input_set = ['train/input/100_100_130_cf_b.of']
-    train_output_set = ['train/output/lbm.out']
-    train_args = ['300 reference.dat 0 1 100_100_130_cf_b.of > 470.lbm.train.out 2> 470.lbm.train.err']
-    train_cmp_cmds = ['fpcmp -a 0.0000001 470.lbm.train.out lbm.out > 470.lbm.train.cmp']
-    ref_input_set = ['ref/input/100_100_130_ldc.of']
-    ref_output_set = ['ref/output/lbm.out']
-    ref_args = ['3000 reference.dat 0 0 100_100_130_ldc.of > 470.lbm.ref.out 2> 470.lbm.ref.err']
-    ref_cmp_cmds = ['fpcmp -a 0.0000001 470.lbm.ref.out lbm.out > 470.lbm.ref.cmp']
+    year = "2006"
+    category = "fp"
+    benchmark = "470.lbm"
+
+    train_input_set = ["train/input/100_100_130_cf_b.of"]
+    train_output_set = ["train/output/lbm.out"]
+    train_args = [
+        "300 reference.dat 0 1 100_100_130_cf_b.of > 470.lbm.train.out 2> 470.lbm.train.err"
+    ]
+    train_cmp_cmds = [
+        "fpcmp -a 0.0000001 470.lbm.train.out lbm.out > 470.lbm.train.cmp"
+    ]
+    ref_input_set = ["ref/input/100_100_130_ldc.of"]
+    ref_output_set = ["ref/output/lbm.out"]
+    ref_args = [
+        "3000 reference.dat 0 0 100_100_130_ldc.of > 470.lbm.ref.out 2> 470.lbm.ref.err"
+    ]
+    ref_cmp_cmds = ["fpcmp -a 0.0000001 470.lbm.ref.out lbm.out > 470.lbm.ref.cmp"]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_470_lbm
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/fp/482.sphinx3/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import os, shutil
 import spec
 
+
 class SPEC2006_482_sphinx3(spec.TestModule):
-    year = '2006'
-    category = 'fp'
-    benchmark = '482.sphinx3'
-
-    train_input_set = ['all/input/model', 'train/input/beams.dat', 'train/input/an406-fcaw-b.le.raw', 'train/input/an407-fcaw-b.le.raw', 'train/input/an408-fcaw-b.le.raw', 'train/input/an409-fcaw-b.le.raw', 'train/input/an410-fcaw-b.le.raw', 'train/input/args.an4']
-    train_output_set = ['train/output/an4.log']
-    train_args = ['ctlfile . args.an4 > 482.sphinx3.an4.out 2> 482.sphinx3.an4.err']
-    train_cmp_cmds = ['sed -i bak "s/\\.le//g" 482.sphinx3.an4.out ; sed -i bak "s,[^ ]*/\\([^/]*\\.c\\),\\1," 482.sphinx3.an4.out; fpcmp -r .001 482.sphinx3.an4.out an4.log > 482.sphinx3.an4.cmp']
-    ref_input_set = ['all/input/model', 'ref/input/beams.dat', 'ref/input/an391-mjwl-b.le.raw', 'ref/input/an400-miry-b.le.raw', 'ref/input/an419-fjlp-b.le.raw', 'ref/input/an428-fvap-b.le.raw', 'ref/input/an437-mjgm-b.le.raw', 'ref/input/cen1-fjlp-b.le.raw', 'ref/input/cen2-fjlp-b.le.raw', 'ref/input/cen3-fjlp-b.le.raw', 'ref/input/cen4-fjlp-b.le.raw', 'ref/input/cen5-fjlp-b.le.raw', 'ref/input/cen6-fjlp-b.le.raw', 'ref/input/cen7-fjlp-b.le.raw', 'ref/input/cen8-fjlp-b.le.raw', 'ref/input/an392-mjwl-b.le.raw', 'ref/input/an401-mdms2-b.le.raw', 'ref/input/an420-fjlp-b.le.raw', 'ref/input/an429-fvap-b.le.raw', 'ref/input/an438-mjgm-b.le.raw', 'ref/input/cen1-fvap-b.le.raw', 'ref/input/cen2-fvap-b.le.raw', 'ref/input/cen3-fvap-b.le.raw', 'ref/input/cen4-fvap-b.le.raw', 'ref/input/cen5-fvap-b.le.raw', 'ref/input/cen6-fvap-b.le.raw', 'ref/input/cen7-fvap-b.le.raw', 'ref/input/cen8-fvap-b.le.raw', 'ref/input/an393-mjwl-b.le.raw', 'ref/input/an402-mdms2-b.le.raw', 'ref/input/an421-menk-b.le.raw', 'ref/input/an430-fvap-b.le.raw', 'ref/input/an439-mjgm-b.le.raw', 'ref/input/cen1-marh-b.le.raw', 'ref/input/cen2-marh-b.le.raw', 'ref/input/cen3-marh-b.le.raw', 'ref/input/cen4-marh-b.le.raw', 'ref/input/cen5-marh-b.le.raw', 'ref/input/cen6-marh-b.le.raw', 'ref/input/cen7-marh-b.le.raw', 'ref/input/cen8-marh-b.le.raw', 'ref/input/an394-mjwl-b.le.raw', 'ref/input/an403-mdms2-b.le.raw', 'ref/input/an422-menk-b.le.raw', 'ref/input/an431-marh-b.le.raw', 'ref/input/an440-mjgm-b.le.raw', 'ref/input/cen1-mdms2-b.le.raw', 'ref/input/cen2-mdms2-b.le.raw', 'ref/input/cen3-mdms2-b.le.raw', 'ref/input/cen4-mdms2-b.le.raw', 'ref/input/cen5-mdms2-b.le.raw', 'ref/input/cen6-mdms2-b.le.raw', 'ref/input/cen7-mdms2-b.le.raw', 'ref/input/cen8-mdms2-b.le.raw', 'ref/input/an395-mjwl-b.le.raw', 'ref/input/an404-mdms2-b.le.raw', 'ref/input/an423-menk-b.le.raw', 'ref/input/an432-marh-b.le.raw', 'ref/input/an441-mmxg-b.le.raw', 'ref/input/cen1-menk-b.le.raw', 'ref/input/cen2-menk-b.le.raw', 'ref/input/cen3-menk-b.le.raw', 'ref/input/cen4-menk-b.le.raw', 'ref/input/cen5-menk-b.le.raw', 'ref/input/cen6-menk-b.le.raw', 'ref/input/cen7-menk-b.le.raw', 'ref/input/cen8-menk-b.le.raw', 'ref/input/an396-miry-b.le.raw', 'ref/input/an405-mdms2-b.le.raw', 'ref/input/an424-menk-b.le.raw', 'ref/input/an433-marh-b.le.raw', 'ref/input/an442-mmxg-b.le.raw', 'ref/input/cen1-miry-b.le.raw', 'ref/input/cen2-miry-b.le.raw', 'ref/input/cen3-miry-b.le.raw', 'ref/input/cen4-miry-b.le.raw', 'ref/input/cen5-miry-b.le.raw', 'ref/input/cen6-miry-b.le.raw', 'ref/input/cen7-miry-b.le.raw', 'ref/input/cen8-miry-b.le.raw', 'ref/input/an397-miry-b.le.raw', 'ref/input/an416-fjlp-b.le.raw', 'ref/input/an425-menk-b.le.raw', 'ref/input/an434-marh-b.le.raw', 'ref/input/an443-mmxg-b.le.raw', 'ref/input/cen1-mjgm-b.le.raw', 'ref/input/cen2-mjgm-b.le.raw', 'ref/input/cen3-mjgm-b.le.raw', 'ref/input/cen4-mjgm-b.le.raw', 'ref/input/cen5-mjgm-b.le.raw', 'ref/input/cen6-mjgm-b.le.raw', 'ref/input/cen7-mjgm-b.le.raw', 'ref/input/cen8-mjgm-b.le.raw', 'ref/input/an398-miry-b.le.raw', 'ref/input/an417-fjlp-b.le.raw', 'ref/input/an426-fvap-b.le.raw', 'ref/input/an435-marh-b.le.raw', 'ref/input/an444-mmxg-b.le.raw', 'ref/input/cen1-mjwl-b.le.raw', 'ref/input/cen2-mjwl-b.le.raw', 'ref/input/cen3-mjwl-b.le.raw', 'ref/input/cen4-mjwl-b.le.raw', 'ref/input/cen5-mjwl-b.le.raw', 'ref/input/cen6-mjwl-b.le.raw', 'ref/input/cen7-mjwl-b.le.raw', 'ref/input/cen8-mjwl-b.le.raw', 'ref/input/an399-miry-b.le.raw', 'ref/input/an418-fjlp-b.le.raw', 'ref/input/an427-fvap-b.le.raw', 'ref/input/an436-mjgm-b.le.raw', 'ref/input/an445-mmxg-b.le.raw', 'ref/input/cen1-mmxg-b.le.raw', 'ref/input/cen2-mmxg-b.le.raw', 'ref/input/cen3-mmxg-b.le.raw', 'ref/input/cen4-mmxg-b.le.raw', 'ref/input/cen5-mmxg-b.le.raw', 'ref/input/cen6-mmxg-b.le.raw', 'ref/input/cen7-mmxg-b.le.raw', 'ref/input/cen8-mmxg-b.le.raw', 'ref/input/args.an4']
-    ref_output_set = ['ref/output/an4.log']
-    ref_args = ['ctlfile . args.an4 > 482.sphinx3.an4.out 2> 482.sphinx3.an4.err']
-    ref_cmp_cmds = ['sed -i bak "s/\\.le//g" 482.sphinx3.an4.out ; sed -i bak "s,[^ ]*/\\([^/]*\\.c\\),\\1," 482.sphinx3.an4.out; fpcmp -r .001 482.sphinx3.an4.out an4.log > 482.sphinx3.an4.cmp']
+    year = "2006"
+    category = "fp"
+    benchmark = "482.sphinx3"
+
+    train_input_set = [
+        "all/input/model",
+        "train/input/beams.dat",
+        "train/input/an406-fcaw-b.le.raw",
+        "train/input/an407-fcaw-b.le.raw",
+        "train/input/an408-fcaw-b.le.raw",
+        "train/input/an409-fcaw-b.le.raw",
+        "train/input/an410-fcaw-b.le.raw",
+        "train/input/args.an4",
+    ]
+    train_output_set = ["train/output/an4.log"]
+    train_args = ["ctlfile . args.an4 > 482.sphinx3.an4.out 2> 482.sphinx3.an4.err"]
+    train_cmp_cmds = [
+        'sed -i bak "s/\\.le//g" 482.sphinx3.an4.out ; sed -i bak "s,[^ ]*/\\([^/]*\\.c\\),\\1," 482.sphinx3.an4.out; fpcmp -r .001 482.sphinx3.an4.out an4.log > 482.sphinx3.an4.cmp'
+    ]
+    ref_input_set = [
+        "all/input/model",
+        "ref/input/beams.dat",
+        "ref/input/an391-mjwl-b.le.raw",
+        "ref/input/an400-miry-b.le.raw",
+        "ref/input/an419-fjlp-b.le.raw",
+        "ref/input/an428-fvap-b.le.raw",
+        "ref/input/an437-mjgm-b.le.raw",
+        "ref/input/cen1-fjlp-b.le.raw",
+        "ref/input/cen2-fjlp-b.le.raw",
+        "ref/input/cen3-fjlp-b.le.raw",
+        "ref/input/cen4-fjlp-b.le.raw",
+        "ref/input/cen5-fjlp-b.le.raw",
+        "ref/input/cen6-fjlp-b.le.raw",
+        "ref/input/cen7-fjlp-b.le.raw",
+        "ref/input/cen8-fjlp-b.le.raw",
+        "ref/input/an392-mjwl-b.le.raw",
+        "ref/input/an401-mdms2-b.le.raw",
+        "ref/input/an420-fjlp-b.le.raw",
+        "ref/input/an429-fvap-b.le.raw",
+        "ref/input/an438-mjgm-b.le.raw",
+        "ref/input/cen1-fvap-b.le.raw",
+        "ref/input/cen2-fvap-b.le.raw",
+        "ref/input/cen3-fvap-b.le.raw",
+        "ref/input/cen4-fvap-b.le.raw",
+        "ref/input/cen5-fvap-b.le.raw",
+        "ref/input/cen6-fvap-b.le.raw",
+        "ref/input/cen7-fvap-b.le.raw",
+        "ref/input/cen8-fvap-b.le.raw",
+        "ref/input/an393-mjwl-b.le.raw",
+        "ref/input/an402-mdms2-b.le.raw",
+        "ref/input/an421-menk-b.le.raw",
+        "ref/input/an430-fvap-b.le.raw",
+        "ref/input/an439-mjgm-b.le.raw",
+        "ref/input/cen1-marh-b.le.raw",
+        "ref/input/cen2-marh-b.le.raw",
+        "ref/input/cen3-marh-b.le.raw",
+        "ref/input/cen4-marh-b.le.raw",
+        "ref/input/cen5-marh-b.le.raw",
+        "ref/input/cen6-marh-b.le.raw",
+        "ref/input/cen7-marh-b.le.raw",
+        "ref/input/cen8-marh-b.le.raw",
+        "ref/input/an394-mjwl-b.le.raw",
+        "ref/input/an403-mdms2-b.le.raw",
+        "ref/input/an422-menk-b.le.raw",
+        "ref/input/an431-marh-b.le.raw",
+        "ref/input/an440-mjgm-b.le.raw",
+        "ref/input/cen1-mdms2-b.le.raw",
+        "ref/input/cen2-mdms2-b.le.raw",
+        "ref/input/cen3-mdms2-b.le.raw",
+        "ref/input/cen4-mdms2-b.le.raw",
+        "ref/input/cen5-mdms2-b.le.raw",
+        "ref/input/cen6-mdms2-b.le.raw",
+        "ref/input/cen7-mdms2-b.le.raw",
+        "ref/input/cen8-mdms2-b.le.raw",
+        "ref/input/an395-mjwl-b.le.raw",
+        "ref/input/an404-mdms2-b.le.raw",
+        "ref/input/an423-menk-b.le.raw",
+        "ref/input/an432-marh-b.le.raw",
+        "ref/input/an441-mmxg-b.le.raw",
+        "ref/input/cen1-menk-b.le.raw",
+        "ref/input/cen2-menk-b.le.raw",
+        "ref/input/cen3-menk-b.le.raw",
+        "ref/input/cen4-menk-b.le.raw",
+        "ref/input/cen5-menk-b.le.raw",
+        "ref/input/cen6-menk-b.le.raw",
+        "ref/input/cen7-menk-b.le.raw",
+        "ref/input/cen8-menk-b.le.raw",
+        "ref/input/an396-miry-b.le.raw",
+        "ref/input/an405-mdms2-b.le.raw",
+        "ref/input/an424-menk-b.le.raw",
+        "ref/input/an433-marh-b.le.raw",
+        "ref/input/an442-mmxg-b.le.raw",
+        "ref/input/cen1-miry-b.le.raw",
+        "ref/input/cen2-miry-b.le.raw",
+        "ref/input/cen3-miry-b.le.raw",
+        "ref/input/cen4-miry-b.le.raw",
+        "ref/input/cen5-miry-b.le.raw",
+        "ref/input/cen6-miry-b.le.raw",
+        "ref/input/cen7-miry-b.le.raw",
+        "ref/input/cen8-miry-b.le.raw",
+        "ref/input/an397-miry-b.le.raw",
+        "ref/input/an416-fjlp-b.le.raw",
+        "ref/input/an425-menk-b.le.raw",
+        "ref/input/an434-marh-b.le.raw",
+        "ref/input/an443-mmxg-b.le.raw",
+        "ref/input/cen1-mjgm-b.le.raw",
+        "ref/input/cen2-mjgm-b.le.raw",
+        "ref/input/cen3-mjgm-b.le.raw",
+        "ref/input/cen4-mjgm-b.le.raw",
+        "ref/input/cen5-mjgm-b.le.raw",
+        "ref/input/cen6-mjgm-b.le.raw",
+        "ref/input/cen7-mjgm-b.le.raw",
+        "ref/input/cen8-mjgm-b.le.raw",
+        "ref/input/an398-miry-b.le.raw",
+        "ref/input/an417-fjlp-b.le.raw",
+        "ref/input/an426-fvap-b.le.raw",
+        "ref/input/an435-marh-b.le.raw",
+        "ref/input/an444-mmxg-b.le.raw",
+        "ref/input/cen1-mjwl-b.le.raw",
+        "ref/input/cen2-mjwl-b.le.raw",
+        "ref/input/cen3-mjwl-b.le.raw",
+        "ref/input/cen4-mjwl-b.le.raw",
+        "ref/input/cen5-mjwl-b.le.raw",
+        "ref/input/cen6-mjwl-b.le.raw",
+        "ref/input/cen7-mjwl-b.le.raw",
+        "ref/input/cen8-mjwl-b.le.raw",
+        "ref/input/an399-miry-b.le.raw",
+        "ref/input/an418-fjlp-b.le.raw",
+        "ref/input/an427-fvap-b.le.raw",
+        "ref/input/an436-mjgm-b.le.raw",
+        "ref/input/an445-mmxg-b.le.raw",
+        "ref/input/cen1-mmxg-b.le.raw",
+        "ref/input/cen2-mmxg-b.le.raw",
+        "ref/input/cen3-mmxg-b.le.raw",
+        "ref/input/cen4-mmxg-b.le.raw",
+        "ref/input/cen5-mmxg-b.le.raw",
+        "ref/input/cen6-mmxg-b.le.raw",
+        "ref/input/cen7-mmxg-b.le.raw",
+        "ref/input/cen8-mmxg-b.le.raw",
+        "ref/input/args.an4",
+    ]
+    ref_output_set = ["ref/output/an4.log"]
+    ref_args = ["ctlfile . args.an4 > 482.sphinx3.an4.out 2> 482.sphinx3.an4.err"]
+    ref_cmp_cmds = [
+        'sed -i bak "s/\\.le//g" 482.sphinx3.an4.out ; sed -i bak "s,[^ ]*/\\([^/]*\\.c\\),\\1," 482.sphinx3.an4.out; fpcmp -r .001 482.sphinx3.an4.out an4.log > 482.sphinx3.an4.cmp'
+    ]
 
     def copy_input_set(self, dest_dir, size):
         spec.TestModule.copy_input_set(self, dest_dir, size)
         # FIXME: this currently only supports little endian!
-        shutil.copy(os.path.join(self.SRCROOT, size, 'ctlfile.little-endian'), os.path.join(dest_dir, 'ctlfile'))
+        shutil.copy(
+            os.path.join(self.SRCROOT, size, "ctlfile.little-endian"),
+            os.path.join(dest_dir, "ctlfile"),
+        )
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_482_sphinx3
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/400.perlbench/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_400_perlbench(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '400.perlbench'
-
-    train_input_set = ['all/input/cpu2006_mhonarc.rc', 'all/input/lib', 'all/input/rules', 'train/input/scrabbl.in', 'train/input/dictionary', 'all/input/diffmail.pl', 'train/input/perfect.pl', 'train/input/scrabbl.pl', 'all/input/splitmail.pl']
-    train_output_set = ['train/output/diffmail.2.550.15.24.23.100.out', 'train/output/perfect.b.3.out', 'train/output/scrabbl.out', 'train/output/splitmail.535.13.25.24.1091.out']
-    train_args = ['-Ilib diffmail.pl 2 550 15 24 23 100 > 400.perlbench.diffmail.out 2> 400.perlbench.diffmail.err', '-Ilib perfect.pl b 3 > 400.perlbench.perfect.out 2> 400.perlbench.perfect.err', '-Ilib scrabbl.pl < scrabbl.in > 400.perlbench.scrabbl.out 2> 400.perlbench.scrabbl.err', '-Ilib splitmail.pl 535 13 25 24 1091 > 400.perlbench.splitmail.out 2> 400.perlbench.splitmail.err']
-    train_cmp_cmds = ['diff 400.perlbench.diffmail.out diffmail.2.550.15.24.23.100.out --strip-trailing-cr > 400.perlbench.diffmail.cmp', 'diff 400.perlbench.perfect.out perfect.b.3.out --strip-trailing-cr > 400.perlbench.perfect.cmp', 'diff 400.perlbench.scrabbl.out scrabbl.out --strip-trailing-cr > 400.perlbench.scrabbl.cmp', 'diff 400.perlbench.splitmail.out splitmail.535.13.25.24.1091.out --strip-trailing-cr > 400.perlbench.splitmail.cmp']
-    ref_input_set = ['all/input/cpu2006_mhonarc.rc', 'all/input/lib', 'all/input/rules', 'ref/input/checkspam.pl', 'all/input/diffmail.pl', 'all/input/splitmail.pl']
-    ref_output_set = ['ref/output/checkspam.2500.5.25.11.150.1.1.1.1.out', 'ref/output/diffmail.4.800.10.17.19.300.out', 'ref/output/splitmail.1600.12.26.16.4500.out']
-    ref_args = ['-Ilib checkspam.pl 2500 5 25 11 150 1 1 1 1 > 400.perlbench.checkspam.out 2> 400.perlbench.checkspam.err', '-Ilib diffmail.pl 4 800 10 17 19 300 > 400.perlbench.diffmail.out 2> 400.perlbench.diffmail.err', '-Ilib splitmail.pl 1600 12 26 16 4500 > 400.perlbench.splitmail.out 2> 400.perlbench.splitmail.err']
-    ref_cmp_cmds = ['diff 400.perlbench.checkspam.out checkspam.2500.5.25.11.150.1.1.1.1.out --strip-trailing-cr > 400.perlbench.checkspam.cmp', 'diff 400.perlbench.diffmail.out diffmail.4.800.10.17.19.300.out --strip-trailing-cr > 400.perlbench.diffmail.cmp', 'diff 400.perlbench.splitmail.out splitmail.1600.12.26.16.4500.out --strip-trailing-cr > 400.perlbench.splitmail.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "400.perlbench"
+
+    train_input_set = [
+        "all/input/cpu2006_mhonarc.rc",
+        "all/input/lib",
+        "all/input/rules",
+        "train/input/scrabbl.in",
+        "train/input/dictionary",
+        "all/input/diffmail.pl",
+        "train/input/perfect.pl",
+        "train/input/scrabbl.pl",
+        "all/input/splitmail.pl",
+    ]
+    train_output_set = [
+        "train/output/diffmail.2.550.15.24.23.100.out",
+        "train/output/perfect.b.3.out",
+        "train/output/scrabbl.out",
+        "train/output/splitmail.535.13.25.24.1091.out",
+    ]
+    train_args = [
+        "-Ilib diffmail.pl 2 550 15 24 23 100 > 400.perlbench.diffmail.out 2> 400.perlbench.diffmail.err",
+        "-Ilib perfect.pl b 3 > 400.perlbench.perfect.out 2> 400.perlbench.perfect.err",
+        "-Ilib scrabbl.pl < scrabbl.in > 400.perlbench.scrabbl.out 2> 400.perlbench.scrabbl.err",
+        "-Ilib splitmail.pl 535 13 25 24 1091 > 400.perlbench.splitmail.out 2> 400.perlbench.splitmail.err",
+    ]
+    train_cmp_cmds = [
+        "diff 400.perlbench.diffmail.out diffmail.2.550.15.24.23.100.out --strip-trailing-cr > 400.perlbench.diffmail.cmp",
+        "diff 400.perlbench.perfect.out perfect.b.3.out --strip-trailing-cr > 400.perlbench.perfect.cmp",
+        "diff 400.perlbench.scrabbl.out scrabbl.out --strip-trailing-cr > 400.perlbench.scrabbl.cmp",
+        "diff 400.perlbench.splitmail.out splitmail.535.13.25.24.1091.out --strip-trailing-cr > 400.perlbench.splitmail.cmp",
+    ]
+    ref_input_set = [
+        "all/input/cpu2006_mhonarc.rc",
+        "all/input/lib",
+        "all/input/rules",
+        "ref/input/checkspam.pl",
+        "all/input/diffmail.pl",
+        "all/input/splitmail.pl",
+    ]
+    ref_output_set = [
+        "ref/output/checkspam.2500.5.25.11.150.1.1.1.1.out",
+        "ref/output/diffmail.4.800.10.17.19.300.out",
+        "ref/output/splitmail.1600.12.26.16.4500.out",
+    ]
+    ref_args = [
+        "-Ilib checkspam.pl 2500 5 25 11 150 1 1 1 1 > 400.perlbench.checkspam.out 2> 400.perlbench.checkspam.err",
+        "-Ilib diffmail.pl 4 800 10 17 19 300 > 400.perlbench.diffmail.out 2> 400.perlbench.diffmail.err",
+        "-Ilib splitmail.pl 1600 12 26 16 4500 > 400.perlbench.splitmail.out 2> 400.perlbench.splitmail.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 400.perlbench.checkspam.out checkspam.2500.5.25.11.150.1.1.1.1.out --strip-trailing-cr > 400.perlbench.checkspam.cmp",
+        "diff 400.perlbench.diffmail.out diffmail.4.800.10.17.19.300.out --strip-trailing-cr > 400.perlbench.diffmail.cmp",
+        "diff 400.perlbench.splitmail.out splitmail.1600.12.26.16.4500.out --strip-trailing-cr > 400.perlbench.splitmail.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_400_perlbench
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/401.bzip2/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_401_bzip2(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '401.bzip2'
-
-    train_input_set = ['train/input/byoudoin.jpg', 'all/input/input.combined', 'all/input/input.program']
-    train_output_set = ['train/output/byoudoin.jpg.out', 'train/output/input.combined.out', 'train/output/input.program.out']
-    train_args = ['byoudoin.jpg 5 > 401.bzip2.byoudoin.out 2> 401.bzip2.byoudoin.err', 'input.combined 80 > 401.bzip2.combined.out 2> 401.bzip2.combined.err', 'input.program 10 > 401.bzip2.program.out 2> 401.bzip2.program.err']
-    train_cmp_cmds = ['diff 401.bzip2.byoudoin.out byoudoin.jpg.out --strip-trailing-cr > 401.bzip2.byoudoin.cmp', 'diff 401.bzip2.combined.out input.combined.out --strip-trailing-cr > 401.bzip2.combined.cmp', 'diff 401.bzip2.program.out input.program.out --strip-trailing-cr > 401.bzip2.program.cmp']
-    ref_input_set = ['ref/input/chicken.jpg', 'all/input/input.combined', 'ref/input/text.html', 'ref/input/liberty.jpg', 'all/input/input.program', 'ref/input/input.source']
-    ref_output_set = ['ref/output/chicken.jpg.out', 'ref/output/input.combined.out', 'ref/output/text.html.out', 'ref/output/liberty.jpg.out', 'ref/output/input.program.out', 'ref/output/input.source.out']
-    ref_args = ['chicken.jpg 30 > 401.bzip2.chicken.out 2> 401.bzip2.chicken.err', 'input.combined 200 > 401.bzip2.combined.out 2> 401.bzip2.combined.err', 'text.html 280 > 401.bzip2.html.out 2> 401.bzip2.html.err', 'liberty.jpg 30 > 401.bzip2.liberty.out 2> 401.bzip2.liberty.err', 'input.program 280 > 401.bzip2.program.out 2> 401.bzip2.program.err', 'input.source 280 > 401.bzip2.source.out 2> 401.bzip2.source.err']
-    ref_cmp_cmds = ['diff 401.bzip2.chicken.out chicken.jpg.out --strip-trailing-cr > 401.bzip2.chicken.cmp', 'diff 401.bzip2.combined.out input.combined.out --strip-trailing-cr > 401.bzip2.combined.cmp', 'diff 401.bzip2.html.out text.html.out --strip-trailing-cr > 401.bzip2.html.cmp', 'diff 401.bzip2.liberty.out liberty.jpg.out --strip-trailing-cr > 401.bzip2.liberty.cmp', 'diff 401.bzip2.program.out input.program.out --strip-trailing-cr > 401.bzip2.program.cmp', 'diff 401.bzip2.source.out input.source.out --strip-trailing-cr > 401.bzip2.source.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "401.bzip2"
+
+    train_input_set = [
+        "train/input/byoudoin.jpg",
+        "all/input/input.combined",
+        "all/input/input.program",
+    ]
+    train_output_set = [
+        "train/output/byoudoin.jpg.out",
+        "train/output/input.combined.out",
+        "train/output/input.program.out",
+    ]
+    train_args = [
+        "byoudoin.jpg 5 > 401.bzip2.byoudoin.out 2> 401.bzip2.byoudoin.err",
+        "input.combined 80 > 401.bzip2.combined.out 2> 401.bzip2.combined.err",
+        "input.program 10 > 401.bzip2.program.out 2> 401.bzip2.program.err",
+    ]
+    train_cmp_cmds = [
+        "diff 401.bzip2.byoudoin.out byoudoin.jpg.out --strip-trailing-cr > 401.bzip2.byoudoin.cmp",
+        "diff 401.bzip2.combined.out input.combined.out --strip-trailing-cr > 401.bzip2.combined.cmp",
+        "diff 401.bzip2.program.out input.program.out --strip-trailing-cr > 401.bzip2.program.cmp",
+    ]
+    ref_input_set = [
+        "ref/input/chicken.jpg",
+        "all/input/input.combined",
+        "ref/input/text.html",
+        "ref/input/liberty.jpg",
+        "all/input/input.program",
+        "ref/input/input.source",
+    ]
+    ref_output_set = [
+        "ref/output/chicken.jpg.out",
+        "ref/output/input.combined.out",
+        "ref/output/text.html.out",
+        "ref/output/liberty.jpg.out",
+        "ref/output/input.program.out",
+        "ref/output/input.source.out",
+    ]
+    ref_args = [
+        "chicken.jpg 30 > 401.bzip2.chicken.out 2> 401.bzip2.chicken.err",
+        "input.combined 200 > 401.bzip2.combined.out 2> 401.bzip2.combined.err",
+        "text.html 280 > 401.bzip2.html.out 2> 401.bzip2.html.err",
+        "liberty.jpg 30 > 401.bzip2.liberty.out 2> 401.bzip2.liberty.err",
+        "input.program 280 > 401.bzip2.program.out 2> 401.bzip2.program.err",
+        "input.source 280 > 401.bzip2.source.out 2> 401.bzip2.source.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 401.bzip2.chicken.out chicken.jpg.out --strip-trailing-cr > 401.bzip2.chicken.cmp",
+        "diff 401.bzip2.combined.out input.combined.out --strip-trailing-cr > 401.bzip2.combined.cmp",
+        "diff 401.bzip2.html.out text.html.out --strip-trailing-cr > 401.bzip2.html.cmp",
+        "diff 401.bzip2.liberty.out liberty.jpg.out --strip-trailing-cr > 401.bzip2.liberty.cmp",
+        "diff 401.bzip2.program.out input.program.out --strip-trailing-cr > 401.bzip2.program.cmp",
+        "diff 401.bzip2.source.out input.source.out --strip-trailing-cr > 401.bzip2.source.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_401_bzip2
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/403.gcc/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_403_gcc(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '403.gcc'
-
-    train_input_set = ['train/input/integrate.i']
-    train_output_set = ['train/output/integrate.s']
-    train_args = ['integrate.i -o - > 403.gcc.integrate.out 2> 403.gcc.integrate.err']
-    train_cmp_cmds = ['diff 403.gcc.integrate.out integrate.s --strip-trailing-cr > 403.gcc.integrate.cmp']
-    ref_input_set = ['ref/input/166.i', 'ref/input/200.i', 'ref/input/c-typeck.i', 'ref/input/cp-decl.i', 'ref/input/expr.i', 'ref/input/expr2.i', 'ref/input/scilab.i']
-    ref_output_set = ['ref/output/166.s', 'ref/output/200.s', 'ref/output/c-typeck.s', 'ref/output/cp-decl.s', 'ref/output/expr.s', 'ref/output/expr2.s', 'ref/output/scilab.s']
-    ref_args = ['166.i -o - > 403.gcc.166.out 2> 403.gcc.166.err', '200.i -o - > 403.gcc.200.out 2> 403.gcc.200.err', 'c-typeck.i -o - > 403.gcc.c-typeck.out 2> 403.gcc.c-typeck.err', 'cp-decl.i -o - > 403.gcc.cp-decl.out 2> 403.gcc.cp-decl.err', 'expr.i -o - > 403.gcc.expr.out 2> 403.gcc.expr.err', 'expr2.i -o - > 403.gcc.expr2.out 2> 403.gcc.expr2.err', 'scilab.i -o - > 403.gcc.scilab.out 2> 403.gcc.scilab.err']
-    ref_cmp_cmds = ['diff 403.gcc.166.out 166.s --strip-trailing-cr > 403.gcc.166.cmp', 'diff 403.gcc.200.out 200.s --strip-trailing-cr > 403.gcc.200.cmp', 'diff 403.gcc.c-typeck.out c-typeck.s --strip-trailing-cr > 403.gcc.c-typeck.cmp', 'diff 403.gcc.cp-decl.out cp-decl.s --strip-trailing-cr > 403.gcc.cp-decl.cmp', 'diff 403.gcc.expr.out expr.s --strip-trailing-cr > 403.gcc.expr.cmp', 'diff 403.gcc.expr2.out expr2.s --strip-trailing-cr > 403.gcc.expr2.cmp', 'diff 403.gcc.scilab.out scilab.s --strip-trailing-cr > 403.gcc.scilab.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "403.gcc"
+
+    train_input_set = ["train/input/integrate.i"]
+    train_output_set = ["train/output/integrate.s"]
+    train_args = ["integrate.i -o - > 403.gcc.integrate.out 2> 403.gcc.integrate.err"]
+    train_cmp_cmds = [
+        "diff 403.gcc.integrate.out integrate.s --strip-trailing-cr > 403.gcc.integrate.cmp"
+    ]
+    ref_input_set = [
+        "ref/input/166.i",
+        "ref/input/200.i",
+        "ref/input/c-typeck.i",
+        "ref/input/cp-decl.i",
+        "ref/input/expr.i",
+        "ref/input/expr2.i",
+        "ref/input/scilab.i",
+    ]
+    ref_output_set = [
+        "ref/output/166.s",
+        "ref/output/200.s",
+        "ref/output/c-typeck.s",
+        "ref/output/cp-decl.s",
+        "ref/output/expr.s",
+        "ref/output/expr2.s",
+        "ref/output/scilab.s",
+    ]
+    ref_args = [
+        "166.i -o - > 403.gcc.166.out 2> 403.gcc.166.err",
+        "200.i -o - > 403.gcc.200.out 2> 403.gcc.200.err",
+        "c-typeck.i -o - > 403.gcc.c-typeck.out 2> 403.gcc.c-typeck.err",
+        "cp-decl.i -o - > 403.gcc.cp-decl.out 2> 403.gcc.cp-decl.err",
+        "expr.i -o - > 403.gcc.expr.out 2> 403.gcc.expr.err",
+        "expr2.i -o - > 403.gcc.expr2.out 2> 403.gcc.expr2.err",
+        "scilab.i -o - > 403.gcc.scilab.out 2> 403.gcc.scilab.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 403.gcc.166.out 166.s --strip-trailing-cr > 403.gcc.166.cmp",
+        "diff 403.gcc.200.out 200.s --strip-trailing-cr > 403.gcc.200.cmp",
+        "diff 403.gcc.c-typeck.out c-typeck.s --strip-trailing-cr > 403.gcc.c-typeck.cmp",
+        "diff 403.gcc.cp-decl.out cp-decl.s --strip-trailing-cr > 403.gcc.cp-decl.cmp",
+        "diff 403.gcc.expr.out expr.s --strip-trailing-cr > 403.gcc.expr.cmp",
+        "diff 403.gcc.expr2.out expr2.s --strip-trailing-cr > 403.gcc.expr2.cmp",
+        "diff 403.gcc.scilab.out scilab.s --strip-trailing-cr > 403.gcc.scilab.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_403_gcc
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/429.mcf/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_429_mcf(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '429.mcf'
-
-    train_input_set = ['train/input/inp.in']
-    train_output_set = ['train/output/inp.out']
-    train_args = ['inp.in > 429.mcf.inp.out 2> 429.mcf.inp.err']
-    train_cmp_cmds = ['diff 429.mcf.inp.out inp.out --strip-trailing-cr > 429.mcf.inp.cmp']
-    ref_input_set = ['ref/input/inp.in']
+    year = "2006"
+    category = "int"
+    benchmark = "429.mcf"
+
+    train_input_set = ["train/input/inp.in"]
+    train_output_set = ["train/output/inp.out"]
+    train_args = ["inp.in > 429.mcf.inp.out 2> 429.mcf.inp.err"]
+    train_cmp_cmds = [
+        "diff 429.mcf.inp.out inp.out --strip-trailing-cr > 429.mcf.inp.cmp"
+    ]
+    ref_input_set = ["ref/input/inp.in"]
     ref_output_set = []
-    ref_args = ['inp.in > 429.mcf.inp.out 2> 429.mcf.inp.err']
+    ref_args = ["inp.in > 429.mcf.inp.out 2> 429.mcf.inp.err"]
     ref_cmp_cmds = []
 
+
 # This is the only required entry point to the module.
 test_class = SPEC2006_429_mcf
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/445.gobmk/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_445_gobmk(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '445.gobmk'
-
-    train_input_set = ['all/input/games', 'all/input/golois', 'train/input/arb.tst', 'train/input/arend.tst', 'train/input/arion.tst', 'train/input/atari_atari.tst', 'train/input/blunder.tst', 'train/input/buzco.tst', 'train/input/nicklas2.tst', 'train/input/nicklas4.tst']
-    train_output_set = ['train/output/arb.out', 'train/output/arend.out', 'train/output/arion.out', 'train/output/atari_atari.out', 'train/output/blunder.out', 'train/output/buzco.out', 'train/output/nicklas2.out', 'train/output/nicklas4.out']
-    train_args = ['--quiet --mode gtp < arb.tst > 445.gobmk.arb.out 2> 445.gobmk.arb.err', '--quiet --mode gtp < arend.tst > 445.gobmk.arend.out 2> 445.gobmk.arend.err', '--quiet --mode gtp < arion.tst > 445.gobmk.arion.out 2> 445.gobmk.arion.err', '--quiet --mode gtp < atari_atari.tst > 445.gobmk.atari_atari.out 2> 445.gobmk.atari_atari.err', '--quiet --mode gtp < blunder.tst > 445.gobmk.blunder.out 2> 445.gobmk.blunder.err', '--quiet --mode gtp < buzco.tst > 445.gobmk.buzco.out 2> 445.gobmk.buzco.err', '--quiet --mode gtp < nicklas2.tst > 445.gobmk.nicklas2.out 2> 445.gobmk.nicklas2.err', '--quiet --mode gtp < nicklas4.tst > 445.gobmk.nicklas4.out 2> 445.gobmk.nicklas4.err']
-    train_cmp_cmds = ['diff 445.gobmk.arb.out arb.out --strip-trailing-cr > 445.gobmk.arb.cmp', 'diff 445.gobmk.arend.out arend.out --strip-trailing-cr > 445.gobmk.arend.cmp', 'diff 445.gobmk.arion.out arion.out --strip-trailing-cr > 445.gobmk.arion.cmp', 'diff 445.gobmk.atari_atari.out atari_atari.out --strip-trailing-cr > 445.gobmk.atari_atari.cmp', 'diff 445.gobmk.blunder.out blunder.out --strip-trailing-cr > 445.gobmk.blunder.cmp', 'diff 445.gobmk.buzco.out buzco.out --strip-trailing-cr > 445.gobmk.buzco.cmp', 'diff 445.gobmk.nicklas2.out nicklas2.out --strip-trailing-cr > 445.gobmk.nicklas2.cmp', 'diff 445.gobmk.nicklas4.out nicklas4.out --strip-trailing-cr > 445.gobmk.nicklas4.cmp']
-    ref_input_set = ['all/input/games', 'all/input/golois', 'ref/input/13x13.tst', 'ref/input/nngs.tst', 'ref/input/score2.tst', 'ref/input/trevorc.tst', 'ref/input/trevord.tst']
-    ref_output_set = ['ref/output/13x13.out', 'ref/output/nngs.out', 'ref/output/score2.out', 'ref/output/trevorc.out', 'ref/output/trevord.out']
-    ref_args = ['--quiet --mode gtp < 13x13.tst > 445.gobmk.13x13.out 2> 445.gobmk.13x13.err', '--quiet --mode gtp < nngs.tst > 445.gobmk.nngs.out 2> 445.gobmk.nngs.err', '--quiet --mode gtp < score2.tst > 445.gobmk.score2.out 2> 445.gobmk.score2.err', '--quiet --mode gtp < trevorc.tst > 445.gobmk.trevorc.out 2> 445.gobmk.trevorc.err', '--quiet --mode gtp < trevord.tst > 445.gobmk.trevord.out 2> 445.gobmk.trevord.err']
-    ref_cmp_cmds = ['diff 445.gobmk.13x13.out 13x13.out --strip-trailing-cr > 445.gobmk.13x13.cmp', 'diff 445.gobmk.nngs.out nngs.out --strip-trailing-cr > 445.gobmk.nngs.cmp', 'diff 445.gobmk.score2.out score2.out --strip-trailing-cr > 445.gobmk.score2.cmp', 'diff 445.gobmk.trevorc.out trevorc.out --strip-trailing-cr > 445.gobmk.trevorc.cmp', 'diff 445.gobmk.trevord.out trevord.out --strip-trailing-cr > 445.gobmk.trevord.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "445.gobmk"
+
+    train_input_set = [
+        "all/input/games",
+        "all/input/golois",
+        "train/input/arb.tst",
+        "train/input/arend.tst",
+        "train/input/arion.tst",
+        "train/input/atari_atari.tst",
+        "train/input/blunder.tst",
+        "train/input/buzco.tst",
+        "train/input/nicklas2.tst",
+        "train/input/nicklas4.tst",
+    ]
+    train_output_set = [
+        "train/output/arb.out",
+        "train/output/arend.out",
+        "train/output/arion.out",
+        "train/output/atari_atari.out",
+        "train/output/blunder.out",
+        "train/output/buzco.out",
+        "train/output/nicklas2.out",
+        "train/output/nicklas4.out",
+    ]
+    train_args = [
+        "--quiet --mode gtp < arb.tst > 445.gobmk.arb.out 2> 445.gobmk.arb.err",
+        "--quiet --mode gtp < arend.tst > 445.gobmk.arend.out 2> 445.gobmk.arend.err",
+        "--quiet --mode gtp < arion.tst > 445.gobmk.arion.out 2> 445.gobmk.arion.err",
+        "--quiet --mode gtp < atari_atari.tst > 445.gobmk.atari_atari.out 2> 445.gobmk.atari_atari.err",
+        "--quiet --mode gtp < blunder.tst > 445.gobmk.blunder.out 2> 445.gobmk.blunder.err",
+        "--quiet --mode gtp < buzco.tst > 445.gobmk.buzco.out 2> 445.gobmk.buzco.err",
+        "--quiet --mode gtp < nicklas2.tst > 445.gobmk.nicklas2.out 2> 445.gobmk.nicklas2.err",
+        "--quiet --mode gtp < nicklas4.tst > 445.gobmk.nicklas4.out 2> 445.gobmk.nicklas4.err",
+    ]
+    train_cmp_cmds = [
+        "diff 445.gobmk.arb.out arb.out --strip-trailing-cr > 445.gobmk.arb.cmp",
+        "diff 445.gobmk.arend.out arend.out --strip-trailing-cr > 445.gobmk.arend.cmp",
+        "diff 445.gobmk.arion.out arion.out --strip-trailing-cr > 445.gobmk.arion.cmp",
+        "diff 445.gobmk.atari_atari.out atari_atari.out --strip-trailing-cr > 445.gobmk.atari_atari.cmp",
+        "diff 445.gobmk.blunder.out blunder.out --strip-trailing-cr > 445.gobmk.blunder.cmp",
+        "diff 445.gobmk.buzco.out buzco.out --strip-trailing-cr > 445.gobmk.buzco.cmp",
+        "diff 445.gobmk.nicklas2.out nicklas2.out --strip-trailing-cr > 445.gobmk.nicklas2.cmp",
+        "diff 445.gobmk.nicklas4.out nicklas4.out --strip-trailing-cr > 445.gobmk.nicklas4.cmp",
+    ]
+    ref_input_set = [
+        "all/input/games",
+        "all/input/golois",
+        "ref/input/13x13.tst",
+        "ref/input/nngs.tst",
+        "ref/input/score2.tst",
+        "ref/input/trevorc.tst",
+        "ref/input/trevord.tst",
+    ]
+    ref_output_set = [
+        "ref/output/13x13.out",
+        "ref/output/nngs.out",
+        "ref/output/score2.out",
+        "ref/output/trevorc.out",
+        "ref/output/trevord.out",
+    ]
+    ref_args = [
+        "--quiet --mode gtp < 13x13.tst > 445.gobmk.13x13.out 2> 445.gobmk.13x13.err",
+        "--quiet --mode gtp < nngs.tst > 445.gobmk.nngs.out 2> 445.gobmk.nngs.err",
+        "--quiet --mode gtp < score2.tst > 445.gobmk.score2.out 2> 445.gobmk.score2.err",
+        "--quiet --mode gtp < trevorc.tst > 445.gobmk.trevorc.out 2> 445.gobmk.trevorc.err",
+        "--quiet --mode gtp < trevord.tst > 445.gobmk.trevord.out 2> 445.gobmk.trevord.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 445.gobmk.13x13.out 13x13.out --strip-trailing-cr > 445.gobmk.13x13.cmp",
+        "diff 445.gobmk.nngs.out nngs.out --strip-trailing-cr > 445.gobmk.nngs.cmp",
+        "diff 445.gobmk.score2.out score2.out --strip-trailing-cr > 445.gobmk.score2.cmp",
+        "diff 445.gobmk.trevorc.out trevorc.out --strip-trailing-cr > 445.gobmk.trevorc.cmp",
+        "diff 445.gobmk.trevord.out trevord.out --strip-trailing-cr > 445.gobmk.trevord.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_445_gobmk
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/456.hmmer/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_456_hmmer(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '456.hmmer'
-
-    train_input_set = ['train/input/leng100.hmm']
-    train_output_set = ['train/output/leng100.out']
-    train_args = ['--fixed 0 --mean 325 --num 5000 --sd 200 --seed 0 leng100.hmm > 456.hmmer.leng100.out 2> 456.hmmer.leng100.err']
-    train_cmp_cmds = ['diff 456.hmmer.leng100.out leng100.out --strip-trailing-cr > 456.hmmer.leng100.cmp']
-    ref_input_set = ['ref/input/nph3.hmm', 'ref/input/swiss41', 'ref/input/retro.hmm']
-    ref_output_set = ['ref/output/nph3.out', 'ref/output/retro.out']
-    ref_args = ['nph3.hmm swiss41 > 456.hmmer.nph3.out 2> 456.hmmer.nph3.err', '--fixed 0 --mean 500 --num 500000 --sd 350 --seed 0 retro.hmm > 456.hmmer.retro.out 2> 456.hmmer.retro.err']
-    ref_cmp_cmds = ['diff 456.hmmer.nph3.out nph3.out --strip-trailing-cr > 456.hmmer.nph3.cmp', 'diff 456.hmmer.retro.out retro.out --strip-trailing-cr > 456.hmmer.retro.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "456.hmmer"
+
+    train_input_set = ["train/input/leng100.hmm"]
+    train_output_set = ["train/output/leng100.out"]
+    train_args = [
+        "--fixed 0 --mean 325 --num 5000 --sd 200 --seed 0 leng100.hmm > 456.hmmer.leng100.out 2> 456.hmmer.leng100.err"
+    ]
+    train_cmp_cmds = [
+        "diff 456.hmmer.leng100.out leng100.out --strip-trailing-cr > 456.hmmer.leng100.cmp"
+    ]
+    ref_input_set = ["ref/input/nph3.hmm", "ref/input/swiss41", "ref/input/retro.hmm"]
+    ref_output_set = ["ref/output/nph3.out", "ref/output/retro.out"]
+    ref_args = [
+        "nph3.hmm swiss41 > 456.hmmer.nph3.out 2> 456.hmmer.nph3.err",
+        "--fixed 0 --mean 500 --num 500000 --sd 350 --seed 0 retro.hmm > 456.hmmer.retro.out 2> 456.hmmer.retro.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 456.hmmer.nph3.out nph3.out --strip-trailing-cr > 456.hmmer.nph3.cmp",
+        "diff 456.hmmer.retro.out retro.out --strip-trailing-cr > 456.hmmer.retro.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_456_hmmer
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/458.sjeng/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_458_sjeng(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '458.sjeng'
-
-    train_input_set = ['train/input/train.txt']
-    train_output_set = ['train/output/train.out']
-    train_args = ['train.txt > 458.sjeng.input1.out 2> 458.sjeng.input1.err']
-    train_cmp_cmds = ['diff 458.sjeng.input1.out train.out --strip-trailing-cr > 458.sjeng.input1.cmp']
-    ref_input_set = ['ref/input/ref.txt']
-    ref_output_set = ['ref/output/ref.out']
-    ref_args = ['ref.txt > 458.sjeng.input1.out 2> 458.sjeng.input1.err']
-    ref_cmp_cmds = ['diff 458.sjeng.input1.out ref.out --strip-trailing-cr > 458.sjeng.input1.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "458.sjeng"
+
+    train_input_set = ["train/input/train.txt"]
+    train_output_set = ["train/output/train.out"]
+    train_args = ["train.txt > 458.sjeng.input1.out 2> 458.sjeng.input1.err"]
+    train_cmp_cmds = [
+        "diff 458.sjeng.input1.out train.out --strip-trailing-cr > 458.sjeng.input1.cmp"
+    ]
+    ref_input_set = ["ref/input/ref.txt"]
+    ref_output_set = ["ref/output/ref.out"]
+    ref_args = ["ref.txt > 458.sjeng.input1.out 2> 458.sjeng.input1.err"]
+    ref_cmp_cmds = [
+        "diff 458.sjeng.input1.out ref.out --strip-trailing-cr > 458.sjeng.input1.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_458_sjeng
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/462.libquantum/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_462_libquantum(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '462.libquantum'
+    year = "2006"
+    category = "int"
+    benchmark = "462.libquantum"
 
     train_input_set = []
-    train_output_set = ['train/output/train.out']
-    train_args = ['143 25 > 462.libquantum.143.out 2> 462.libquantum.143.err']
-    train_cmp_cmds = ['diff 462.libquantum.143.out train.out --strip-trailing-cr > 462.libquantum.143.cmp']
+    train_output_set = ["train/output/train.out"]
+    train_args = ["143 25 > 462.libquantum.143.out 2> 462.libquantum.143.err"]
+    train_cmp_cmds = [
+        "diff 462.libquantum.143.out train.out --strip-trailing-cr > 462.libquantum.143.cmp"
+    ]
     ref_input_set = []
-    ref_output_set = ['ref/output/ref.out']
-    ref_args = ['1397 8 > 462.libquantum.1397.out 2> 462.libquantum.1397.err']
-    ref_cmp_cmds = ['diff 462.libquantum.1397.out ref.out --strip-trailing-cr > 462.libquantum.1397.cmp']
+    ref_output_set = ["ref/output/ref.out"]
+    ref_args = ["1397 8 > 462.libquantum.1397.out 2> 462.libquantum.1397.err"]
+    ref_cmp_cmds = [
+        "diff 462.libquantum.1397.out ref.out --strip-trailing-cr > 462.libquantum.1397.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_462_libquantum
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/464.h264ref/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_464_h264ref(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '464.h264ref'
-
-    train_input_set = ['all/input/foreman_qcif.yuv', 'train/input/foreman_train_encoder_baseline.cfg', 'all/input/leakybucketrate.cfg']
-    train_output_set = ['train/output/foreman_train_baseline_encodelog.out']
-    train_args = ['-d foreman_train_encoder_baseline.cfg > 464.h264ref.foreman_train_encoder_baseline.out 2> 464.h264ref.foreman_train_encoder_baseline.err']
-    train_cmp_cmds = ['diff 464.h264ref.foreman_train_encoder_baseline.out foreman_train_baseline_encodelog.out --strip-trailing-cr > 464.h264ref.foreman_train_encoder_baseline.cmp']
-    ref_input_set = ['all/input/foreman_qcif.yuv', 'ref/input/sss.yuv', 'all/input/leakybucketrate.cfg', 'ref/input/foreman_ref_encoder_main.cfg', 'ref/input/foreman_ref_encoder_baseline.cfg', 'ref/input/sss_encoder_main.cfg']
-    ref_output_set = ['ref/output/foreman_ref_baseline_encodelog.out', 'ref/output/foreman_ref_main_encodelog.out', 'ref/output/sss_main_encodelog.out']
-    ref_args = ['-d foreman_ref_encoder_baseline.cfg > 464.h264ref.foreman_ref_encoder_baseline.out 2> 464.h264ref.foreman_ref_encoder_baseline.err', '-d foreman_ref_encoder_main.cfg > 464.h264ref.foreman_ref_encoder_main.out 2> 464.h264ref.foreman_ref_encoder_main.err', '-d sss_encoder_main.cfg > 464.h264ref.sss_encoder_main.out 2> 464.h264ref.sss_encoder_main.err']
-    ref_cmp_cmds = ['diff 464.h264ref.foreman_ref_encoder_baseline.out foreman_ref_baseline_encodelog.out --strip-trailing-cr > 464.h264ref.foreman_ref_encoder_baseline.cmp', 'diff 464.h264ref.foreman_ref_encoder_main.out foreman_ref_main_encodelog.out --strip-trailing-cr > 464.h264ref.foreman_ref_encoder_main.cmp', 'diff 464.h264ref.sss_encoder_main.out sss_main_encodelog.out --strip-trailing-cr > 464.h264ref.sss_encoder_main.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "464.h264ref"
+
+    train_input_set = [
+        "all/input/foreman_qcif.yuv",
+        "train/input/foreman_train_encoder_baseline.cfg",
+        "all/input/leakybucketrate.cfg",
+    ]
+    train_output_set = ["train/output/foreman_train_baseline_encodelog.out"]
+    train_args = [
+        "-d foreman_train_encoder_baseline.cfg > 464.h264ref.foreman_train_encoder_baseline.out 2> 464.h264ref.foreman_train_encoder_baseline.err"
+    ]
+    train_cmp_cmds = [
+        "diff 464.h264ref.foreman_train_encoder_baseline.out foreman_train_baseline_encodelog.out --strip-trailing-cr > 464.h264ref.foreman_train_encoder_baseline.cmp"
+    ]
+    ref_input_set = [
+        "all/input/foreman_qcif.yuv",
+        "ref/input/sss.yuv",
+        "all/input/leakybucketrate.cfg",
+        "ref/input/foreman_ref_encoder_main.cfg",
+        "ref/input/foreman_ref_encoder_baseline.cfg",
+        "ref/input/sss_encoder_main.cfg",
+    ]
+    ref_output_set = [
+        "ref/output/foreman_ref_baseline_encodelog.out",
+        "ref/output/foreman_ref_main_encodelog.out",
+        "ref/output/sss_main_encodelog.out",
+    ]
+    ref_args = [
+        "-d foreman_ref_encoder_baseline.cfg > 464.h264ref.foreman_ref_encoder_baseline.out 2> 464.h264ref.foreman_ref_encoder_baseline.err",
+        "-d foreman_ref_encoder_main.cfg > 464.h264ref.foreman_ref_encoder_main.out 2> 464.h264ref.foreman_ref_encoder_main.err",
+        "-d sss_encoder_main.cfg > 464.h264ref.sss_encoder_main.out 2> 464.h264ref.sss_encoder_main.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 464.h264ref.foreman_ref_encoder_baseline.out foreman_ref_baseline_encodelog.out --strip-trailing-cr > 464.h264ref.foreman_ref_encoder_baseline.cmp",
+        "diff 464.h264ref.foreman_ref_encoder_main.out foreman_ref_main_encodelog.out --strip-trailing-cr > 464.h264ref.foreman_ref_encoder_main.cmp",
+        "diff 464.h264ref.sss_encoder_main.out sss_main_encodelog.out --strip-trailing-cr > 464.h264ref.sss_encoder_main.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_464_h264ref
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/471.omnetpp/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_471_omnetpp(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '471.omnetpp'
-
-    train_input_set = ['train/input/omnetpp.ini']
-    train_output_set = ['train/output/omnetpp.log']
-    train_args = ['omnetpp.ini > 471.omnetpp.input1.out 2> 471.omnetpp.input1.err']
-    train_cmp_cmds = ['diff 471.omnetpp.input1.out omnetpp.log --strip-trailing-cr > 471.omnetpp.input1.cmp']
-    ref_input_set = ['ref/input/omnetpp.ini']
-    ref_output_set = ['ref/output/omnetpp.log']
-    ref_args = ['omnetpp.ini > 471.omnetpp.input1.out 2> 471.omnetpp.input1.err']
-    ref_cmp_cmds = ['fpcmp -a 0.000001 -r 0.00001 471.omnetpp.input1.out omnetpp.log > 471.omnetpp.input1.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "471.omnetpp"
+
+    train_input_set = ["train/input/omnetpp.ini"]
+    train_output_set = ["train/output/omnetpp.log"]
+    train_args = ["omnetpp.ini > 471.omnetpp.input1.out 2> 471.omnetpp.input1.err"]
+    train_cmp_cmds = [
+        "diff 471.omnetpp.input1.out omnetpp.log --strip-trailing-cr > 471.omnetpp.input1.cmp"
+    ]
+    ref_input_set = ["ref/input/omnetpp.ini"]
+    ref_output_set = ["ref/output/omnetpp.log"]
+    ref_args = ["omnetpp.ini > 471.omnetpp.input1.out 2> 471.omnetpp.input1.err"]
+    ref_cmp_cmds = [
+        "fpcmp -a 0.000001 -r 0.00001 471.omnetpp.input1.out omnetpp.log > 471.omnetpp.input1.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_471_omnetpp
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/473.astar/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_473_astar(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '473.astar'
-
-    train_input_set = ['train/input/rivers.bin', 'train/input/BigLakes1024.bin', 'train/input/BigLakes1024.cfg', 'train/input/rivers1.cfg']
-    train_output_set = ['train/output/BigLakes1024.out', 'train/output/rivers1.out']
-    train_args = ['BigLakes1024.cfg > 473.astar.BigLakes1024.out 2> 473.astar.BigLakes1024.err', 'rivers1.cfg > 473.astar.rivers1.out 2> 473.astar.rivers1.err']
-    train_cmp_cmds = ['diff 473.astar.BigLakes1024.out BigLakes1024.out --strip-trailing-cr > 473.astar.BigLakes1024.cmp', 'diff 473.astar.rivers1.out rivers1.out --strip-trailing-cr > 473.astar.rivers1.cmp']
-    ref_input_set = ['ref/input/rivers.bin', 'ref/input/BigLakes2048.bin', 'ref/input/BigLakes2048.cfg', 'ref/input/rivers.cfg']
-    ref_output_set = ['ref/output/BigLakes2048.out', 'ref/output/rivers.out']
-    ref_args = ['BigLakes2048.cfg > 473.astar.BigLakes2048.out 2> 473.astar.BigLakes2048.err', 'rivers.cfg > 473.astar.rivers.out 2> 473.astar.rivers.err']
-    ref_cmp_cmds = ['diff 473.astar.BigLakes2048.out BigLakes2048.out --strip-trailing-cr > 473.astar.BigLakes2048.cmp', 'diff 473.astar.rivers.out rivers.out --strip-trailing-cr > 473.astar.rivers.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "473.astar"
+
+    train_input_set = [
+        "train/input/rivers.bin",
+        "train/input/BigLakes1024.bin",
+        "train/input/BigLakes1024.cfg",
+        "train/input/rivers1.cfg",
+    ]
+    train_output_set = ["train/output/BigLakes1024.out", "train/output/rivers1.out"]
+    train_args = [
+        "BigLakes1024.cfg > 473.astar.BigLakes1024.out 2> 473.astar.BigLakes1024.err",
+        "rivers1.cfg > 473.astar.rivers1.out 2> 473.astar.rivers1.err",
+    ]
+    train_cmp_cmds = [
+        "diff 473.astar.BigLakes1024.out BigLakes1024.out --strip-trailing-cr > 473.astar.BigLakes1024.cmp",
+        "diff 473.astar.rivers1.out rivers1.out --strip-trailing-cr > 473.astar.rivers1.cmp",
+    ]
+    ref_input_set = [
+        "ref/input/rivers.bin",
+        "ref/input/BigLakes2048.bin",
+        "ref/input/BigLakes2048.cfg",
+        "ref/input/rivers.cfg",
+    ]
+    ref_output_set = ["ref/output/BigLakes2048.out", "ref/output/rivers.out"]
+    ref_args = [
+        "BigLakes2048.cfg > 473.astar.BigLakes2048.out 2> 473.astar.BigLakes2048.err",
+        "rivers.cfg > 473.astar.rivers.out 2> 473.astar.rivers.err",
+    ]
+    ref_cmp_cmds = [
+        "diff 473.astar.BigLakes2048.out BigLakes2048.out --strip-trailing-cr > 473.astar.BigLakes2048.cmp",
+        "diff 473.astar.rivers.out rivers.out --strip-trailing-cr > 473.astar.rivers.cmp",
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_473_astar
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

LNTBased/speccpu2006/int/483.xalancbmk/TestModule

 #!/usr/bin/env python
 # -*- Python -*-
 
 import spec
 
+
 class SPEC2006_483_xalancbmk(spec.TestModule):
-    year = '2006'
-    category = 'int'
-    benchmark = '483.xalancbmk'
-
-    train_input_set = ['train/input/train.xsd', 'train/input/train.lst', 'train/input/allbooks.xml', 'train/input/xalanc.xsl']
-    train_output_set = ['train/output/train.out']
-    train_args = ['-v allbooks.xml xalanc.xsl > 483.xalancbmk.allbooks.out 2> 483.xalancbmk.allbooks.err']
-    train_cmp_cmds = ['diff 483.xalancbmk.allbooks.out train.out --strip-trailing-cr > 483.xalancbmk.allbooks.cmp']
-    ref_input_set = ['ref/input/t5.xml', 'ref/input/xalanc.xsl', 'ref/input/100mb.xsd']
-    ref_output_set = ['ref/output/ref.out']
-    ref_args = ['-v t5.xml xalanc.xsl > 483.xalancbmk.t5.out 2> 483.xalancbmk.t5.err']
-    ref_cmp_cmds = ['diff 483.xalancbmk.t5.out ref.out --strip-trailing-cr > 483.xalancbmk.t5.cmp']
+    year = "2006"
+    category = "int"
+    benchmark = "483.xalancbmk"
+
+    train_input_set = [
+        "train/input/train.xsd",
+        "train/input/train.lst",
+        "train/input/allbooks.xml",
+        "train/input/xalanc.xsl",
+    ]
+    train_output_set = ["train/output/train.out"]
+    train_args = [
+        "-v allbooks.xml xalanc.xsl > 483.xalancbmk.allbooks.out 2> 483.xalancbmk.allbooks.err"
+    ]
+    train_cmp_cmds = [
+        "diff 483.xalancbmk.allbooks.out train.out --strip-trailing-cr > 483.xalancbmk.allbooks.cmp"
+    ]
+    ref_input_set = ["ref/input/t5.xml", "ref/input/xalanc.xsl", "ref/input/100mb.xsd"]
+    ref_output_set = ["ref/output/ref.out"]
+    ref_args = ["-v t5.xml xalanc.xsl > 483.xalancbmk.t5.out 2> 483.xalancbmk.t5.err"]
+    ref_cmp_cmds = [
+        "diff 483.xalancbmk.t5.out ref.out --strip-trailing-cr > 483.xalancbmk.t5.cmp"
+    ]
+
 
 # This is the only required entry point to the module.
 test_class = SPEC2006_483_xalancbmk
 
 # This is not required, but allows users with LNT in the environment (required
 # for initial imports to work) to execute this test directly.
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_class().main()

MicroBenchmarks/lit.local.cfg

-config.environment['XRAY_OPTIONS'] = 'patch_premain=false xray_naive_log=false'
+config.environment["XRAY_OPTIONS"] = "patch_premain=false xray_naive_log=false"
 test_modules = config.test_modules
-if 'run' in test_modules:
+if "run" in test_modules:
     # Insert microbenchmark module behind 'run'
-    test_modules.insert(test_modules.index('run')+1, 'microbenchmark')
+    test_modules.insert(test_modules.index("run") + 1, "microbenchmark")
     # Timeit results are not useful for microbenchmarks
-    if 'timeit' in test_modules:
-        test_modules.remove('timeit')
+    if "timeit" in test_modules:
+        test_modules.remove("timeit")

lit.cfg

 import logging
 import os
 import site
 import sys
 
 # Setup logging.
 logger = logging.getLogger()
 logger.setLevel(logging.DEBUG)
-file_log = logging.FileHandler("%s/test.log" % config.test_exec_root,
-                               mode="w")
+file_log = logging.FileHandler("%s/test.log" % config.test_exec_root, mode="w")
 file_log.setLevel(logging.DEBUG)
 logger.addHandler(file_log)
 console_log = logging.StreamHandler()
 console_log.setLevel(logging.WARNING)
 logger.addHandler(console_log)
 
 # Load test-suite litsupport code
 site.addsitedir(os.path.dirname(__file__))
 import litsupport.test
 
-config.name = 'test-suite'
+config.name = "test-suite"
 config.test_format = litsupport.test.TestSuiteTest()
-config.suffixes = ['.test']
-config.excludes = ['ABI-Testsuite']
+config.suffixes = [".test"]
+config.excludes = ["ABI-Testsuite"]
 config.traditional_output = False
 config.single_source = False
-if 'SSH_AUTH_SOCK' in os.environ:
-    config.environment['SSH_AUTH_SOCK'] = os.environ['SSH_AUTH_SOCK']
-if not hasattr(config, 'remote_host'):
+if "SSH_AUTH_SOCK" in os.environ:
+    config.environment["SSH_AUTH_SOCK"] = os.environ["SSH_AUTH_SOCK"]
+if not hasattr(config, "remote_host"):
     config.remote_host = ""
-config.remote_host = lit_config.params.get('remote_host', config.remote_host)
+config.remote_host = lit_config.params.get("remote_host", config.remote_host)
 if config.remote_host:
-    config.test_modules.append('remote')
+    config.test_modules.append("remote")
 
 # Load previous test results so we can skip tests that did not change.
-previous_results_file = lit_config.params.get('previous', None)
+previous_results_file = lit_config.params.get("previous", None)
 if previous_results_file:
     import json
+
     config.previous_results = json.load(open(previous_results_file))
 else:
     config.previous_results = None
 
 # Pass on some options to context object:
 config.perf_profile_events = "cycles,cache-misses,branch-misses,instructions"
-if lit_config.params.get('perf_profile_events'):
-    config.perf_profile_events = lit_config.params.get('perf_profile_events')
+if lit_config.params.get("perf_profile_events"):
+    config.perf_profile_events = lit_config.params.get("perf_profile_events")
 
 # Find and initialize lit modules.
-if lit_config.params.get('profile') == 'perf':
-    config.test_modules += ['perf']
+if lit_config.params.get("profile") == "perf":
+    config.test_modules += ["perf"]
 
-if lit_config.params.get('profile') == 'hpmcount':
-    config.test_modules += ['hpmcount']
+if lit_config.params.get("profile") == "hpmcount":
+    config.test_modules += ["hpmcount"]
 
 config.substitutions += [
-   ('%b', os.path.join(config.test_exec_root, "tools")),
+    ("%b", os.path.join(config.test_exec_root, "tools")),
 ]

lit.site.cfg.in

 import sys
 import os
 
-_directory =  os.path.dirname(os.path.abspath(__file__))
+_directory = os.path.dirname(os.path.abspath(__file__))
 
 config.test_source_root = _directory
 config.test_exec_root = _directory
 config.remote_client = "@TEST_SUITE_REMOTE_CLIENT@"
 config.remote_host = "@TEST_SUITE_REMOTE_HOST@"
 config.run_under = "@TEST_SUITE_RUN_UNDER@"
 config.user_mode_emulation = @TEST_SUITE_USER_MODE_EMULATION@
 config.strip_tool = "@CMAKE_STRIP@"
 config.profile_generate = @TEST_SUITE_PROFILE_GENERATE@
 config.llvm_profdata = "@TEST_SUITE_LLVM_PROFDATA@"
-config.test_modules = "@LIT_MODULES@".split(';')
+config.test_modules = "@LIT_MODULES@".split(";")
 
 lit_config.load_config(config, os.path.join(_directory, "lit.cfg"))

litsupport-tests/hash/lit.site.cfg

 import os
+
 mydir = os.path.dirname(__file__)
 config.test_source_root = mydir
 config.test_exec_root = "/tmp/litoutput/hash"
-config.test_modules = [ "run", "hash" ]
+config.test_modules = ["run", "hash"]
 
 lit_config.load_config(config, "../../lit.cfg")

litsupport-tests/run/lit.site.cfg

 import os
+
 mydir = os.path.dirname(__file__)
 config.test_source_root = mydir
 config.test_exec_root = "/tmp/litoutput/run"
-config.test_modules = [ "run" ]
+config.test_modules = ["run"]
 
 lit_config.load_config(config, "../../lit.cfg")

litsupport/modules/__init__.py

 import importlib
 import logging
 import pkgutil
 
 # Load all modules
 modules = dict()
-for importer, modname, ispkg in pkgutil.walk_packages(path=__path__,
-                                                      prefix=__name__+'.'):
+for importer, modname, ispkg in pkgutil.walk_packages(
+    path=__path__, prefix=__name__ + "."
+):
     module = importlib.import_module(modname)
-    if not hasattr(module, 'mutatePlan'):
-        logging.error('Skipping %s: No mutatePlan function' % modname)
+    if not hasattr(module, "mutatePlan"):
+        logging.error("Skipping %s: No mutatePlan function" % modname)
         continue
-    assert modname.startswith('litsupport.modules.')
-    shortname = modname[len('litsupport.modules.'):]
+    assert modname.startswith("litsupport.modules.")
+    shortname = modname[len("litsupport.modules.") :]
     modules[shortname] = module
     logging.info("Loaded test module %s" % module.__file__)

litsupport/modules/codesize.py

 """Test module to collect code size metrics of the benchmark executable."""
 from litsupport import testplan
 import logging
 import os.path
 
 
 def _getCodeSize(context):
     # First get the filesize: This should always work.
     metrics = {}
-    metrics['size'] = os.path.getsize(context.executable)
+    metrics["size"] = os.path.getsize(context.executable)
 
     # If we have the llvm-size tool available get the size per segment.
     filename = context.test.getSourcePath()
     if filename.endswith(".test"):
-        filename = filename[:-len(".test")]
+        filename = filename[: -len(".test")]
     filename += ".size"
     if os.path.exists(filename):
         with open(filename, "r") as fp:
             lines = fp.readlines()
         # First line contains executable name, second line should be a
         # "section   size    addr" header, numbers start after that.
         if "section" not in lines[1] or "size" not in lines[1]:
-            logging.warning("Unexpected output from llvm-size on '%s'",
-                            context.executable)
+            logging.warning(
+                "Unexpected output from llvm-size on '%s'", context.executable
+            )
         else:
             for line in lines[2:]:
                 line = line.strip()
                 if line == "":
                     continue
                 values = line.split()
                 if len(values) < 2:
                     logging.info("Ignoring malformed output line: %s", line)
                     continue
-                if values[0] == 'Total':
+                if values[0] == "Total":
                     continue
                 try:
                     name = values[0]
                     val = int(values[1])
-                    metrics['size.%s' % name] = val
+                    metrics["size.%s" % name] = val
                     # The text size output here comes from llvm-size.
                     # Darwin and GNU produce differently-formatted output.
                     # Check that we have exactly one of the valid outputs.
-                    assert not ('size.__text' in metrics and
-                                'size..text' in metrics), """Both 'size.__text'
+                    assert not (
+                        "size.__text" in metrics and "size..text" in metrics
+                    ), """Both 'size.__text'
                                 and 'size..text' present in metrics.
                                 Only one of them should exist."""
                 except ValueError:
                     logging.info("Ignoring malformed output line: %s", line)
 
     return metrics
 
 
 def mutatePlan(context, plan):
     plan.metric_collectors.append(_getCodeSize)

litsupport/modules/compiletime.py

def _getCompileTime(context):
     if context.config.single_source:
         prefix = "%s." % os.path.basename(context.executable)
 
     compile_time = 0.0
     link_time = 0.0
     dir = os.path.dirname(context.test.getFilePath())
     for path, subdirs, files in os.walk(dir):
         for file in files:
-            if file.endswith('.o.time') and file.startswith(prefix):
+            if file.endswith(".o.time") and file.startswith(prefix):
                 fullpath = os.path.join(path, file)
                 compile_time += timeit.getUserTime(fullpath)
-            if file.endswith('.link.time') and file.startswith(prefix):
+            if file.endswith(".link.time") and file.startswith(prefix):
                 fullpath = os.path.join(path, file)
                 link_time += timeit.getUserTime(fullpath)
     return {
-        'compile_time': compile_time,
-        'link_time': link_time,
+        "compile_time": compile_time,
+        "link_time": link_time,
     }
 
 
 def mutatePlan(context, plan):
     plan.metric_collectors.append(_getCompileTime)

litsupport/modules/hash.py

 """Test module to collect test executable hashsum."""
 from litsupport import testplan
 import hashlib
 import logging
 import platform
 
 
 def compute(context):
-    if hasattr(context, 'executable_hash'):
+    if hasattr(context, "executable_hash"):
         return
     executable = context.executable
     try:
         # Darwin's and Solaris' "strip" don't support these arguments.
-        if platform.system() != 'Darwin' and platform.system() != 'SunOS':
-            stripped_executable = executable + '.stripped'
-            testplan.check_call([context.config.strip_tool,
-                                 '--remove-section=.comment',
-                                 "--remove-section='.note*'",
-                                 '-o', stripped_executable,
-                                 executable])
+        if platform.system() != "Darwin" and platform.system() != "SunOS":
+            stripped_executable = executable + ".stripped"
+            testplan.check_call(
+                [
+                    context.config.strip_tool,
+                    "--remove-section=.comment",
+                    "-o",
+                    stripped_executable,
+                    executable,
+                ]
+            )
             executable = stripped_executable
 
         h = hashlib.md5()
-        h.update(open(executable, 'rb').read())
+        h.update(open(executable, "rb").read())
         context.executable_hash = h.hexdigest()
     except Exception:
-        logging.info('Could not calculate hash for %s' % executable)
-        context.executable_hash = ''
+        logging.info("Could not calculate hash for %s" % executable)
+        context.executable_hash = ""
 
 
 def same_as_previous(context):
     """Check whether hash has changed compared to the results in
     config.previous_results."""
     previous_results = context.config.previous_results
     testname = context.test.getFullName()
     executable_hash = context.executable_hash
     if previous_results and "tests" in previous_results:
         for test in previous_results["tests"]:
             if "name" not in test or test["name"] != testname:
                 continue
             if "metrics" not in test:
                 continue
             metrics = test["metrics"]
             return "hash" in metrics and metrics["hash"] == executable_hash
     return False
 
 
 def _getHash(context):
     compute(context)
-    return {'hash': context.executable_hash}
+    return {"hash": context.executable_hash}
 
 
 def mutatePlan(context, plan):
     plan.metric_collectors.append(_getHash)

litsupport/modules/hpmcount.py

 """Test Module to perform an extra execution of the benchmark in the AIX
 hpmcount tool."""
 from litsupport import shellcommand
 from litsupport import testplan
 from litsupport.modules import run_under
 
 import os
 
 
 def _mutateCommandLine(context, commandline):
     context.profilefile = context.tmpBase + ".hpmcount_data"
     # Storing profile file in context allows other modules to be aware of it.
     cmd = shellcommand.parse(commandline)
-    cmd.wrap('hpmcount', ['-o', context.profilefile])
+    cmd.wrap("hpmcount", ["-o", context.profilefile])
     if cmd.stdout is None:
         cmd.stdout = os.devnull
     else:
         cmd.stdout += ".hpmcount"
     if cmd.stderr is None:
         cmd.stderr = os.devnull
     else:
         cmd.stderr += ".hpmcount"
     return cmd.toCommandline()
 
 
 def mutatePlan(context, plan):
     script = context.parsed_runscript
     if context.config.run_under:
-        script = testplan.mutateScript(context, script,
-                                       run_under.mutateCommandLine)
+        script = testplan.mutateScript(context, script, run_under.mutateCommandLine)
     script = testplan.mutateScript(context, script, _mutateCommandLine)
     plan.profilescript += script
-    plan.metric_collectors.append(
-        lambda context: {'profile': context.profilefile})
+    plan.metric_collectors.append(lambda context: {"profile": context.profilefile})

litsupport/modules/microbenchmark.py

-'''Test module to collect google benchmark results.'''
+"""Test module to collect google benchmark results."""
 from litsupport import shellcommand
 from litsupport import testplan
 import json
 import lit.Test
 
 
 def _mutateCommandLine(context, commandline):
     cmd = shellcommand.parse(commandline)
     cmd.arguments.append("--benchmark_format=json")
     # We need stdout outself to get the benchmark csv data.
     if cmd.stdout is not None:
         raise Exception("Rerouting stdout not allowed for microbenchmarks")
-    benchfile = context.tmpBase + '.bench.json'
+    benchfile = context.tmpBase + ".bench.json"
     cmd.stdout = benchfile
     context.microbenchfiles.append(benchfile)
 
     return cmd.toCommandline()
 
 
 def _mutateScript(context, script):
     return testplan.mutateScript(context, script, _mutateCommandLine)
 
 
 def _collectMicrobenchmarkTime(context, microbenchfiles):
     for f in microbenchfiles:
         content = context.read_result_file(context, f)
         data = json.loads(content)
 
         # Create a micro_result for each benchmark
-        for benchmark in data['benchmarks']:
+        for benchmark in data["benchmarks"]:
             # Name for MicroBenchmark
-            name = benchmark['name']
+            name = benchmark["name"]
 
             # Create Result object with PASS
             microBenchmark = lit.Test.Result(lit.Test.PASS)
 
             # Add the exec_time metric for this result
-            exec_time_metric = lit.Test.toMetricValue(benchmark['cpu_time'])
-            microBenchmark.addMetric('exec_time', exec_time_metric)
+            exec_time_metric = lit.Test.toMetricValue(benchmark["cpu_time"])
+            microBenchmark.addMetric("exec_time", exec_time_metric)
 
             # Add Micro Result
             context.micro_results[name] = microBenchmark
 
     # returning the number of microbenchmarks collected as a metric for the
     # base test
-    return ({
-        'MicroBenchmarks': lit.Test.toMetricValue(len(context.micro_results))
-    })
+    return {"MicroBenchmarks": lit.Test.toMetricValue(len(context.micro_results))}
 
 
 def mutatePlan(context, plan):
     context.microbenchfiles = []
     plan.runscript = _mutateScript(context, plan.runscript)
     plan.metric_collectors.append(
-        lambda context: _collectMicrobenchmarkTime(context,
-                                                   context.microbenchfiles)
+        lambda context: _collectMicrobenchmarkTime(context, context.microbenchfiles)
     )

litsupport/modules/perf.py

 """Test Module to perform an extra execution of the benchmark in the linux
 perf tool."""
 from litsupport import shellcommand
 from litsupport import testplan
 from litsupport.modules import run_under
 
 
 def _mutateCommandLine(context, commandline):
     context.profilefile = context.tmpBase + ".perf_data"
     # Storing profile file in context allows other modules to be aware of it.
     cmd = shellcommand.parse(commandline)
-    cmd.wrap('perf', [
-        'record',
-        '-e', context.config.perf_profile_events,
-        '-o', context.profilefile,
-        '--'
-    ])
+    cmd.wrap(
+        "perf",
+        [
+            "record",
+            "-e",
+            context.config.perf_profile_events,
+            "-o",
+            context.profilefile,
+            "--",
+        ],
+    )
     if cmd.stdout is None:
         cmd.stdout = "/dev/null"
     else:
         cmd.stdout += ".perfrecord"
     if cmd.stderr is None:
         cmd.stderr = "/dev/null"
     else:
         cmd.stderr += ".perfrecord"
     return cmd.toCommandline()
 
 
 def mutatePlan(context, plan):
     script = context.parsed_runscript
     if context.config.run_under:
-        script = testplan.mutateScript(context, script,
-                                       run_under.mutateCommandLine)
+        script = testplan.mutateScript(context, script, run_under.mutateCommandLine)
     script = testplan.mutateScript(context, script, _mutateCommandLine)
     plan.profilescript += script
-    plan.metric_collectors.append(
-        lambda context: {'profile': context.profilefile})
+    plan.metric_collectors.append(lambda context: {"profile": context.profilefile})

litsupport/modules/profilegen.py

 def mutatePlan(context, plan):
     context.profilefiles = []
     # Adjust run steps to set LLVM_PROFILE_FILE environment variable.
     plan.runscript = _mutateScript(context, plan.runscript)
     plan.profile_files += context.profilefiles
 
     # Run profdata merge at the end
     profdatafile = context.executable + ".profdata"
-    args = ['merge', '-output=%s' % profdatafile] + context.profilefiles
+    args = ["merge", "-output=%s" % profdatafile] + context.profilefiles
     mergecmd = shellcommand.ShellCommand(context.config.llvm_profdata, args)
     plan.profilescript += [mergecmd.toCommandline()]

litsupport/modules/remote.py

 """Test module to execute a benchmark through ssh on a remote device.
 This assumes all relevant directories and files are present on the remote
 device (typically transferred via `ninja rsync`, or shared by NFS)."""
 from litsupport import testplan
 import logging
 import os
 import subprocess
 
 
 def _wrap_command(context, command):
     escaped_command = command.replace("'", "'\\''")
-    return "%s %s '%s'" % (context.config.remote_client,
-                           context.config.remote_host, escaped_command)
+    return "%s %s '%s'" % (
+        context.config.remote_client,
+        context.config.remote_host,
+        escaped_command,
+    )
 
 
 def _mutateCommandline(context, commandline):
     return _wrap_command(context, commandline)
 
 
 def _mutateScript(context, script):
     def mutate(context, command):
         return _mutateCommandline(context, command)
+
     return testplan.mutateScript(context, script, mutate)
 
 
 def remote_read_result_file(context, path):
     assert os.path.isabs(path)
     command = _wrap_command(context, "cat '%s'" % path)
     logging.info("$ %s", command)
     return subprocess.check_output(command, shell=True)
 
 
 def mutatePlan(context, plan):
     plan.preparescript = _mutateScript(context, plan.preparescript)
     # We need the temporary directory to exist on the remote as well.
-    command = _wrap_command(context,
-                            "mkdir -p '%s'" % os.path.dirname(context.tmpBase))
+    command = _wrap_command(context, "mkdir -p '%s'" % os.path.dirname(context.tmpBase))
     plan.preparescript.insert(0, command)
     plan.runscript = _mutateScript(context, plan.runscript)
     plan.verifyscript = _mutateScript(context, plan.verifyscript)
     for name, script in plan.metricscripts.items():
         plan.metricscripts[name] = _mutateScript(context, script)
 
     # Merging profile data should happen on the host because that is where
     # the toolchain resides, however we have to retrieve the profile data
     # from the device first, add commands for that to the profile script.
     for path in plan.profile_files:
         assert os.path.isabs(path)
         command = "scp %s:%s %s" % (context.config.remote_host, path, path)
         plan.profilescript.insert(0, command)
 
     assert context.read_result_file is testplan.default_read_result_file
     context.read_result_file = remote_read_result_file

litsupport/modules/run_under.py

 """Test module to run benchmarks in a wrapper application. This is typically
 used to prefix the benchmark command with simulator commands."""
 from litsupport import shellcommand
 from litsupport import testplan
 
 
 def mutateCommandLine(context, commandline):
     cmd = shellcommand.parse(commandline)
     run_under_cmd = shellcommand.parse(context.config.run_under)
 
-    if run_under_cmd.stdin is not None or \
-       run_under_cmd.stdout is not None or \
-       run_under_cmd.stderr is not None or \
-       run_under_cmd.workdir is not None or \
-       run_under_cmd.envvars:
+    if (
+        run_under_cmd.stdin is not None
+        or run_under_cmd.stdout is not None
+        or run_under_cmd.stderr is not None
+        or run_under_cmd.workdir is not None
+        or run_under_cmd.envvars
+    ):
         raise Exception("invalid run_under argument!")
 
     cmd.wrap(run_under_cmd.executable, run_under_cmd.arguments)
 
     return cmd.toCommandline()
 
 
 def mutatePlan(context, plan):
     run_under = context.config.run_under
     if run_under:
-        plan.runscript = testplan.mutateScript(context, plan.runscript,
-                                               mutateCommandLine)
+        plan.runscript = testplan.mutateScript(
+            context, plan.runscript, mutateCommandLine
+        )

litsupport/modules/stats.py

def _getStats(context):
     prefix = ""
     if context.config.single_source:
         prefix = "%s." % os.path.basename(context.executable)
 
     stats = defaultdict(lambda: 0.0)
     dir = os.path.dirname(context.test.getFilePath())
     for path, subdirs, files in os.walk(dir):
         for file in files:
-            if file.endswith('.stats') and file.startswith(prefix):
+            if file.endswith(".stats") and file.startswith(prefix):
                 fullpath = os.path.join(path, file)
                 _mergeStats(stats, fullpath)
 
     if len(stats) == 0:
         logging.warning("No stats for '%s'", context.test.getFullName())
 
     result = dict()
     for key, value in stats.items():
         result[key] = value
     return result
 
 
 def mutatePlan(context, plan):
     plan.metric_collectors.append(_getStats)

litsupport/modules/timeit.py

if not config.traditional_output:
         stderr = cmd.stderr
         if stderr is not None:
             if not os.path.isabs(stderr) and workdir is not None:
                 stderr = os.path.join(workdir, stderr)
             args += ["--redirect-stderr", stderr]
             cmd.stderr = None
     else:
         if cmd.stdout is not None or cmd.stderr is not None:
-            raise Exception("Separate stdout/stderr redirection not " +
-                            "possible with traditional output")
+            raise Exception(
+                "Separate stdout/stderr redirection not "
+                + "possible with traditional output"
+            )
         outfile = context.tmpBase + ".out"
         args += ["--append-exitstatus"]
         args += ["--redirect-output", outfile]
     stdin = cmd.stdin
     if stdin is not None:
         if not os.path.isabs(stdin) and workdir is not None:
             stdin = os.path.join(workdir, stdin)
         args += ["--redirect-input", stdin]

 
 
 def _mutateScript(context, script):
     if not hasattr(context, "timefiles"):
         context.timefiles = []
     return testplan.mutateScript(context, script, _mutateCommandLine)
 
 
-def _collectTime(context, timefiles, metric_name='exec_time'):
+def _collectTime(context, timefiles, metric_name="exec_time"):
     time = 0.0
     for timefile in timefiles:
         filecontent = context.read_result_file(context, timefile)
         time += getUserTimeFromContents(filecontent)
     return {metric_name: time}
 
 
 def mutatePlan(context, plan):
def getUserTime(filename):
     with open(filename) as fd:
         contents = fd.read()
         return getUserTimeFromContents(contents)
 
 
 def getUserTimeFromContents(contents):
     from_bytes = lambda s: s.decode("utf-8") if type(s) == bytes else s
     lines = [from_bytes(l) for l in contents.splitlines()]
-    line = [line for line in lines if line.startswith('user')]
+    line = [line for line in lines if line.startswith("user")]
     assert len(line) == 1
 
-    m = re.match(r'user\s+([0-9.]+)', line[0])
+    m = re.match(r"user\s+([0-9.]+)", line[0])
     return float(m.group(1))

litsupport/shellcommand.py

 """Utilities for analyzing and manipulating shell commands."""
 import shlex
 import logging
 import re
 import os
+
 try:
-        from shlex import quote  # python 3.3 and above
 except ImportError:
-        from pipes import quote  # python 3.2 and earlier
 
 
 class ShellCommand:
     """This class represents a parsed shell command (a subset of posix shell
     commands; see parse()). The parsed form allows direct access to information
     like the executable name, working directory or the file to which
     stdin/stdout/stderr is redirected."""
+
     def __init__(self, executable=None, arguments=None):
         self.stdin = None
         self.stdout = None
         self.stderr = None
         self.executable = executable
         if arguments is None:
             arguments = []
         self.arguments = arguments
def wrap(self, new_executable, args):
         Prefixing `SOMVAR=42 cd mydir && mycmd -v > /dev/null` with `lldb --`
         becomes `SOMEVAR=42 cd mydir && lldb -- mycmd -v > /dev/null`."""
         self.arguments = args + [self.executable] + self.arguments
         self.executable = new_executable
 
 
 # Tokens/keywords for shell command parsing, loosely modeled after posix
 # specification for sh.
-reserved_words = ['!', '{', '}', 'case', 'do', 'done', 'elif', 'else', 'esac',
-                  'fi', 'for', 'if', 'in', 'then', 'until', 'while']
+reserved_words = [
+    "!",
+    "{",
+    "}",
+    "case",
+    "do",
+    "done",
+    "elif",
+    "else",
+    "esac",
+    "fi",
+    "for",
+    "if",
+    "in",
+    "then",
+    "until",
+    "while",
+]
 
-chaining_tokens = set([';', '&&', '||', '|', '&'])
-unhandled_tokens = set([';;', '<<', '>>', '<&', '>&', '<>', '<<-', '>|', '(',
-                        ')'])
+chaining_tokens = set([";", "&&", "||", "|", "&"])
+unhandled_tokens = set([";;", "<<", ">>", "<&", ">&", "<>", "<<-", ">|", "(", ")"])
 
 
 def parse(commandline):
     """Parses a posix shell commandline to a ShellCommand object. This supports
     typical commandline with environment variables, input/output redirection
     and switching directories upfront. It does not support full posix shell
     and will throw an exception if the commandline uses unsupported features.
     """
     result = ShellCommand()
     tokens = shlex.split(commandline)
     i = 0
     first_word = True
     while i < len(tokens):
         token = tokens[i]
         i += 1
-        if token == '<' and i < len(tokens):
+        if token == "<" and i < len(tokens):
             result.stdin = tokens[i]
             i += 1
             continue
-        if token == '>' and i < len(tokens):
+        if token == ">" and i < len(tokens):
             result.stdout = tokens[i]
             i += 1
             continue
-        if token == '2>' and i < len(tokens):
+        if token == "2>" and i < len(tokens):
             result.stderr = tokens[i]
             i += 1
             continue
 
         if first_word:
             # Is it an environment variable assignment?
-            assignment = re.match('([A-Za-z_][A-Za-z_0-9]*)=(.*)', token)
+            assignment = re.match("([A-Za-z_][A-Za-z_0-9]*)=(.*)", token)
             if assignment:
                 result.envvars[assignment.group(1)] = assignment.group(2)
                 continue
             # A reserved word?
             if token in reserved_words or token in unhandled_tokens:
                 raise Exception("Reserved word '%s' not supported" % token)
             result.executable = token
             first_word = False
         else:
             if token in chaining_tokens:
                 # Currently we only allow the special case of 'cd DIR ;'
-                if (token == ';' or token == '&&') and \
-                        result.executable == 'cd' and \
-                        len(result.arguments) == 1:
+                if (
+                    (token == ";" or token == "&&")
+                    and result.executable == "cd"
+                    and len(result.arguments) == 1
+                ):
                     newresult = ShellCommand()
                     newresult.workdir = result.arguments[0]
                     result = newresult
                     first_word = True
                     continue
                 raise Exception("Command chaining not supported yet")
             if token in unhandled_tokens or token in reserved_words:
-                raise Exception("Commandline with '%s' not supported yet" %
-                                token)
+                raise Exception("Commandline with '%s' not supported yet" % token)
             result.arguments.append(token)
     return result
 
 
 # Some executables are just used to cleanup/prepare for a test run, ignore them
 # here. This is from a time when there was no concept of a prepare script,
 # it should not be necessary anymore for new test files.
-_ignore_executables = set(['cd', 'rm', 'cp'])
+_ignore_executables = set(["cd", "rm", "cp"])
 
 
 def getMainExecutable(context):
     """Returns the main executable of the current run script. This skips over
     some commands typically used to setup a benchmark (see _ignore_executables)
     and returns the first executable found in the run script and prints a
     warning if more than one executable is found."""
 
     # Executable name already determined in a previous run?
-    if hasattr(context, 'executable'):
+    if hasattr(context, "executable"):
         return context.executable
 
     executable = None
-    cwd = '.'
+    cwd = "."
     for line in context.parsed_runscript:
         cmd = parse(line)
         if cmd.workdir is not None:
             cwd = os.path.join(cwd, cmd.workdir)
         if cmd.executable in _ignore_executables:
             continue
         new_executable = os.path.join(cwd, cmd.executable)
         # We only support one executable yet for collecting md5sums
         if new_executable != executable and executable is not None:
-            logging.warning("More than one executable used in test %s",
-                            context.test.getFullName())
+            logging.warning(
+                "More than one executable used in test %s", context.test.getFullName()
+            )
         executable = new_executable
     if executable is None:
-        logging.warning("No executable found for test %s",
-                        context.test.getFullName())
+        logging.warning("No executable found for test %s", context.test.getFullName())
     context.executable = executable
     return executable

litsupport/test.py

 import os
 
 
 # The ResultCode constructor has been changed recently in lit.  An additional parameter has ben added, which
 # results in: TypeError: __new__() takes exactly 4 arguments (3 given)
 # However, some users rely on the lit version provided by pypi that does not require or have add_result_category.
 # See for more details: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20200511/780899.html
 try:
-    NOCHANGE = lit.Test.ResultCode('NOCHANGE', 'Executable Unchanged', False)
-    NOEXE = lit.Test.ResultCode('NOEXE', 'Executable Missing', True)
+    NOCHANGE = lit.Test.ResultCode("NOCHANGE", "Executable Unchanged", False)
+    NOEXE = lit.Test.ResultCode("NOEXE", "Executable Missing", True)
 except TypeError:
-    NOCHANGE = lit.Test.ResultCode('NOCHANGE', False)
-    NOEXE = lit.Test.ResultCode('NOEXE', True)
+    NOCHANGE = lit.Test.ResultCode("NOCHANGE", False)
+    NOEXE = lit.Test.ResultCode("NOEXE", True)
 
 
 class TestSuiteTest(lit.formats.ShTest):
     def __init__(self):
         super(TestSuiteTest, self).__init__()
 
     def execute(self, test, litConfig):
         config = test.config
         if config.unsupported:
-            return lit.Test.Result(lit.Test.UNSUPPORTED, 'Test is unsupported')
+            return lit.Test.Result(lit.Test.UNSUPPORTED, "Test is unsupported")
         if litConfig.noExecute:
             return lit.Test.Result(lit.Test.PASS)
 
         # Parse .test file and initialize context
         tmpDir, tmpBase = lit.TestRunner.getTempPaths(test)
         lit.util.mkdir_p(os.path.dirname(tmpBase))
-        context = litsupport.testplan.TestContext(test, litConfig, tmpDir,
-                                                  tmpBase)
+        context = litsupport.testplan.TestContext(test, litConfig, tmpDir, tmpBase)
         litsupport.testfile.parse(context, test.getSourcePath())
         plan = litsupport.testplan.TestPlan()
 
         # Report missing test executables.
         if not os.path.exists(context.executable):
-            return lit.Test.Result(NOEXE, "Executable '%s' is missing" %
-                                   context.executable)
+            return lit.Test.Result(
+                NOEXE, "Executable '%s' is missing" % context.executable
+            )
 
         # Skip unchanged tests
         if config.previous_results:
             litsupport.modules.hash.compute(context)
             if litsupport.modules.hash.same_as_previous(context):
                 result = lit.Test.Result(
-                        NOCHANGE, 'Executable identical to previous run')
+                    NOCHANGE, "Executable identical to previous run"
+                )
                 val = lit.Test.toMetricValue(context.executable_hash)
-                result.addMetric('hash', val)
+                result.addMetric("hash", val)
                 return result
 
         # Let test modules modify the test plan.
         for modulename in config.test_modules:
             module = litsupport.modules.modules.get(modulename)
             if module is None:
                 raise Exception("Unknown testmodule '%s'" % modulename)
             module.mutatePlan(context, plan)
 
         # Execute Test plan
         result = litsupport.testplan.executePlanTestResult(context, plan)
 
         return result

litsupport/testfile.py

 """Parser for .test files"""
-from lit.TestRunner import parseIntegratedTestScriptCommands, \
-        getDefaultSubstitutions, applySubstitutions
+from lit.TestRunner import (
+    parseIntegratedTestScriptCommands,
+    getDefaultSubstitutions,
+    applySubstitutions,
+)
 from litsupport import shellcommand
 import logging
 
 
 def _parseShellCommand(script, ln):
     # Trim trailing whitespace.
     ln = ln.rstrip()
 
     # Collapse lines with trailing '\\'.
-    if script and script[-1][-1] == '\\':
+    if script and script[-1][-1] == "\\":
         script[-1] = script[-1][:-1] + ln
     else:
         script.append(ln)
 
 
 def parse(context, filename):
     """Parse a .test file as used in the llvm test-suite.
     The file comporises of a number of lines starting with RUN: and VERIFY:
     specifying shell commands to run the benchmark and verifying the result.
     Returns a tuple with two arrays for the run and verify commands."""
     # Collect the test lines from the script.
     preparescript = []
     runscript = []
     verifyscript = []
     metricscripts = {}
     # Note that we keep both "RUN" and "RUN:" in the list to stay compatible
     # with older lit versions.
-    keywords = ['PREPARE:', 'PREPARE', 'RUN:', 'RUN', 'VERIFY:', 'VERIFY',
-                'METRIC:', 'METRIC']
-    for line_number, command_type, ln in \
-            parseIntegratedTestScriptCommands(filename, keywords):
-        if command_type.startswith('PREPARE'):
+    keywords = [
+        "PREPARE:",
+        "PREPARE",
+        "RUN:",
+        "RUN",
+        "VERIFY:",
+        "VERIFY",
+        "METRIC:",
+        "METRIC",
+    ]
+    for line_number, command_type, ln in parseIntegratedTestScriptCommands(
+        filename, keywords
+    ):
+        if command_type.startswith("PREPARE"):
             _parseShellCommand(preparescript, ln)
-        elif command_type.startswith('RUN'):
+        elif command_type.startswith("RUN"):
             _parseShellCommand(runscript, ln)
-        elif command_type.startswith('VERIFY'):
+        elif command_type.startswith("VERIFY"):
             _parseShellCommand(verifyscript, ln)
-        elif command_type.startswith('METRIC'):
-            metric, ln = ln.split(':', 1)
+        elif command_type.startswith("METRIC"):
+            metric, ln = ln.split(":", 1)
             metricscript = metricscripts.setdefault(metric.strip(), list())
             _parseShellCommand(metricscript, ln)
         else:
-            raise ValueError("unknown script command type: %r" % (
-                             command_type,))
+            raise ValueError("unknown script command type: %r" % (command_type,))
 
     # Verify the script contains a run line.
     if runscript == []:
         raise ValueError("Test has no RUN: line!")
 
     # Check for unterminated run lines.
     for script in preparescript, runscript, verifyscript:
-        if script and script[-1][-1] == '\\':
-            raise ValueError("Test has unterminated RUN/VERIFY lines " +
-                             "(ending with '\\')")
+        if script and script[-1][-1] == "\\":
+            raise ValueError(
+                "Test has unterminated RUN/VERIFY lines " + "(ending with '\\')"
+            )
 
     # Apply the usual lit substitutions (%s, %S, %p, %T, ...)
     outfile = context.tmpBase + ".out"
-    substitutions = getDefaultSubstitutions(context.test, context.tmpDir,
-                                            context.tmpBase)
-    substitutions += [('%o', outfile)]
+    substitutions = getDefaultSubstitutions(
+        context.test, context.tmpDir, context.tmpBase
+    )
+    substitutions += [("%o", outfile)]
     preparescript = applySubstitutions(preparescript, substitutions)
     runscript = applySubstitutions(runscript, substitutions)
     verifyscript = applySubstitutions(verifyscript, substitutions)
-    metricscripts = {k: applySubstitutions(v, substitutions)
-                     for k, v in metricscripts.items()}
+    metricscripts = {
+        k: applySubstitutions(v, substitutions) for k, v in metricscripts.items()
+    }
 
     # Put things into the context
     context.parsed_preparescript = preparescript
     context.parsed_runscript = runscript
     context.parsed_verifyscript = verifyscript
     context.parsed_metricscripts = metricscripts
     context.executable = shellcommand.getMainExecutable(context)
     if not context.executable:
         logging.error("Could not determine executable name in %s" % filename)

litsupport/testplan.py

 
 class TestPlan(object):
     """Describes how to execute a benchmark and how to collect metrics.
     A script is a list of strings containing shell commands. The available
     scripts are: preparescript, runscript, verifyscript, profilescript,
     metricscripts and are executed in this order.
     metric_collectors contains a list of functions executed after the scripts
     finished."""
+
     def __init__(self):
         self.runscript = []
         self.verifyscript = []
         self.metricscripts = {}
         self.metric_collectors = []
         self.preparescript = []
         self.profile_files = []
         self.profilescript = []
def _executeScript(context, script, scriptBaseName, useExternalSh=True):
     if useExternalSh:
         execdir = None
         executeFunc = lit.TestRunner.executeScript
     else:
         execdir = os.getcwd()
         executeFunc = lit.TestRunner.executeScriptInternal
 
     logging.info("\n".join(script))
-    res = executeFunc(context.test, context.litConfig,
-                      context.tmpBase + "_" + scriptBaseName, script, execdir)
+    res = executeFunc(
+        context.test,
+        context.litConfig,
+        context.tmpBase + "_" + scriptBaseName,
+        script,
+        execdir,
+    )
     # The executeScript() functions return lit.Test.Result in some error
     # conditions instead of the normal tuples. Having different return types is
     # really annoying so we transform it back to the usual tuple.
     if isinstance(res, lit.Test.Result):
         out = ""
         err = res.output
         exitCode = 1
         timeoutInfo = None
def _executePlan(context, plan):
     # Perform various metric extraction steps setup by testing modules.
     for metric_collector in plan.metric_collectors:
         try:
             additional_metrics = metric_collector(context)
             for metric, value in additional_metrics.items():
                 litvalue = lit.Test.toMetricValue(value)
                 context.result_metrics[metric] = litvalue
         except Exception as e:
-            logging.error("Could not collect metric with %s", metric_collector,
-                          exc_info=e)
+            logging.error(
+                "Could not collect metric with %s", metric_collector, exc_info=e
+            )
 
     # Execute the METRIC: part of the test.
     for metric, metricscript in plan.metricscripts.items():
-        out, err, exitCode, timeoutInfo = _executeScript(context, metricscript,
-                                                         "metric")
+        out, err, exitCode, timeoutInfo = _executeScript(
+            context, metricscript, "metric"
+        )
         if exitCode != 0:
             logging.warning("Metric script for '%s' failed", metric)
             continue
         try:
             value = lit.Test.toMetricValue(float(out))
             context.result_metrics[metric] = value
         except ValueError:
-            logging.warning("Metric reported for '%s' is not a float: '%s'",
-                            metric, out)
+            logging.warning(
+                "Metric reported for '%s' is not a float: '%s'", metric, out
+            )
 
     return lit.Test.PASS
 
 
 def executePlanTestResult(context, testplan):
     """Convenience function to invoke _executePlan() and construct a
     lit.test.Result() object for the results."""
     context.result_output = ""
with open(path) as fd:
         return fd.read()
 
 
 class TestContext:
     """This class is used to hold data used while constructing a testrun.
     For example this can be used by modules modifying the commandline with
     extra instrumentation/measurement wrappers to pass the filenames of the
     results to a final data collection step."""
+
     def __init__(self, test, litConfig, tmpDir, tmpBase):
         self.test = test
         self.config = test.config
         self.litConfig = litConfig
         self.tmpDir = tmpDir
         self.tmpBase = tmpBase
         self.read_result_file = default_read_result_file

tools/get-report-time

 #!/usr/bin/env python
 
 import re
 import optparse
 
+
 def main():
-    parser = optparse.OptionParser("""\
+    parser = optparse.OptionParser(
+        """\
 usage: %prog [options] <path>
 
 Reads the file at the given path and extracts any "program times" as used by the
-LLVM test-suite Makefiles.""")
-    opts,args = parser.parse_args()
+LLVM test-suite Makefiles."""
+    )
+    opts, args = parser.parse_args()
     if len(args) != 1:
-        parser.error('invalid number of arguments')
-       
+        parser.error("invalid number of arguments")
     file = open(args[0])
     try:
         re_pattern = re.compile(r"program ([0-9]+\.[0-9]+)")
 
         data = file.read()
         for match in re_pattern.finditer(data):
-          print match.group(1)
+            print(match.group(1))
     finally:
         file.close()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

utils/compare.py

 #!/usr/bin/env python
 """Tool to filter, organize, compare and display benchmarking results. Usefull
 for smaller datasets. It works great with a few dozen runs it is not designed to
 deal with hundreds.
 Requires the pandas library to be installed."""
 from __future__ import print_function
 
 import pandas as pd
 from scipy import stats
 import sys
 import os.path
 import re
 import numbers
 import argparse
 
-GEOMEAN_ROW = 'Geomean difference'
+GEOMEAN_ROW = "Geomean difference"
+
 
 def read_lit_json(filename):
     import json
+
     jsondata = json.load(open(filename))
     columns = []
     columnindexes = {}
     names = set()
-    info_columns = ['hash']
+    info_columns = ["hash"]
     # Pass1: Figure out metrics (= the column index)
-    if 'tests' not in jsondata:
+    if "tests" not in jsondata:
         print("%s: Could not find toplevel 'tests' key")
         sys.exit(1)
-    for test in jsondata['tests']:
+    for test in jsondata["tests"]:
         name = test.get("name")
         if name is None:
             sys.stderr.write("Error: Found unnamed test\n" % name)
             sys.exit(1)
         if name in names:
             sys.stderr.write("Error: Multiple tests with name '%s'\n" % name)
             sys.exit(1)
         if "metrics" not in test:
-            print("Warning: '%s' has no metrics, skipping!" % test['name'])
+            print("Warning: '%s' has no metrics, skipping!" % test["name"])
             continue
         names.add(name)
         for name in test["metrics"].keys():
             if name not in columnindexes:
                 columnindexes[name] = len(columns)
                 columns.append(name)
         for name in test.keys():
             if name not in columnindexes and name in info_columns:
                 columnindexes[name] = len(columns)
                 columns.append(name)
 
     # Pass2 actual data construction
-    nan = float('NaN')
+    nan = float("NaN")
     data = []
     testnames = []
-    for test in jsondata['tests']:
+    for test in jsondata["tests"]:
         if "metrics" not in test:
             continue
-        name = test['name']
-        if 'shortname' in test:
-            name = test['shortname']
+        name = test["name"]
+        if "shortname" in test:
+            name = test["shortname"]
         testnames.append(name)
 
         datarow = [nan] * len(columns)
-        for (metricname, value) in test['metrics'].items():
+        for (metricname, value) in test["metrics"].items():
             datarow[columnindexes[metricname]] = value
         for (name, value) in test.items():
             index = columnindexes.get(name)
             if index is not None:
                 datarow[index] = test[name]
         data.append(datarow)
-    index = pd.Index(testnames, name='Program')
+    index = pd.Index(testnames, name="Program")
     return pd.DataFrame(data=data, index=index, columns=columns)
 
+
 def read_report_simple_csv(filename):
-    return pd.read_csv(filename, na_values=['*'], index_col=0, header=0)
+    return pd.read_csv(filename, na_values=["*"], index_col=0, header=0)
+
 
 def read(name):
     if name.endswith(".json"):
         return read_lit_json(name)
     if name.endswith(".csv"):
         return read_report_simple_csv(name)
-    raise Exception("Cannot determine file format");
+    raise Exception("Cannot determine file format")
+
 
 def readmulti(filenames):
     # Read datasets
     datasetnames = []
     datasets = []
     prev_index = None
     for filename in filenames:
         data = read(filename)
         name = os.path.basename(filename)
         # drop .json/.csv suffix; TODO: Should we rather do this in the printing
         # logic?
-        for ext in ['.csv', '.json']:
+        for ext in [".csv", ".json"]:
             if name.endswith(ext):
-                name = name[:-len(ext)]
+                name = name[: -len(ext)]
         datasets.append(data)
         suffix = ""
         count = 0
         while True:
-            if name+suffix not in datasetnames:
+            if name + suffix not in datasetnames:
                 break
             suffix = str(count)
-            count +=1
+            count += 1
 
-        datasetnames.append(name+suffix)
+        datasetnames.append(name + suffix)
         # Warn if index names are different
         if prev_index is not None and prev_index.name != data.index.name:
-            sys.stderr.write("Warning: Mismatched index names: '%s' vs '%s'\n"
-                             % (prev_index.name, data.index.name))
+            sys.stderr.write(
+                "Warning: Mismatched index names: '%s' vs '%s'\n"
+                % (prev_index.name, data.index.name)
+            )
         prev_index = data.index
     # Merge datasets
-    d = pd.concat(datasets, axis=0, names=['run'], keys=datasetnames)
+    d = pd.concat(datasets, axis=0, names=["run"], keys=datasetnames)
     return d
 
+
 def get_values(values):
     # Create data view without diff column.
-    if 'diff' in values.columns:
-        values = values[[c for c in values.columns if c != 'diff']]
+    if "diff" in values.columns:
+        values = values[[c for c in values.columns if c != "diff"]]
     has_two_runs = len(values.columns) == 2
     if has_two_runs:
-        return (values.iloc[:,0], values.iloc[:,1])
+        return (values.iloc[:, 0], values.iloc[:, 1])
     else:
         return (values.min(axis=1), values.max(axis=1))
 
+
 def add_diff_column(metric, values, absolute_diff=False):
     values0, values1 = get_values(values[metric])
     values0.fillna(0.0, inplace=True)
     values1.fillna(0.0, inplace=True)
     # Quotient or absolute difference?
     if absolute_diff:
-        values[(metric, 'diff')] = values1 - values0
+        values[(metric, "diff")] = values1 - values0
     else:
-        values[(metric, 'diff')] = (values1 / values0) - 1.0
+        values[(metric, "diff")] = (values1 / values0) - 1.0
     return values
 
+
 def add_geomean_row(metrics, data, dataout):
     """
     Normalize values1 over values0, compute geomean difference and add a
     summary row to dataout.
     """
-    gm = pd.DataFrame(index=[GEOMEAN_ROW], columns=dataout.columns,
-                      dtype='float64')
+    gm = pd.DataFrame(index=[GEOMEAN_ROW], columns=dataout.columns, dtype="float64")
     for metric in metrics:
         values0, values1 = get_values(data[metric])
         # Avoid infinite values in the diff and instead use NaN, as otherwise
         # the computation of the geometric mean will fail.
-        values0 = values0.replace({0: float('NaN')})
+        values0 = values0.replace({0: float("NaN")})
         relative = values1 / values0
         gm_diff = stats.gmean(relative.dropna()) - 1.0
-        gm[(metric, 'diff')] = gm_diff
+        gm[(metric, "diff")] = gm_diff
     gm.Program = GEOMEAN_ROW
     return pd.concat([dataout, gm])
 
-def filter_failed(data, key='Exec'):
+
+def filter_failed(data, key="Exec"):
     return data.loc[data[key] == "pass"]
 
-def filter_short(data, threshold, key='Exec_Time'):
+
+def filter_short(data, threshold, key="Exec_Time"):
     return data.loc[data[key] >= threshold]
 
-def filter_same_hash(data, key='hash'):
+
+def filter_same_hash(data, key="hash"):
     assert key in data.columns
     assert data.index.get_level_values(0).nunique() > 1
 
     return data.groupby(level=1).filter(lambda x: x[key].nunique() != 1)
 
+
 def filter_blacklist(data, blacklist):
     return data.loc[~(data.index.get_level_values(1).isin(blacklist))]
 
+
 def print_filter_stats(reason, before, after):
     n_before = len(before.groupby(level=1))
     n_after = len(after.groupby(level=1))
     n_filtered = n_before - n_after
     if n_filtered != 0:
         print("%s: %s (filtered out)" % (reason, n_filtered))
 
+
 # Truncate a string to a maximum length by keeping a prefix, a suffix and ...
 # in the middle
 def truncate(string, prefix_len, suffix_len):
-    return re.sub("^(.{%d}).*(.{%d})$" % (prefix_len, suffix_len),
-                  "\g<1>...\g<2>", string)
+    return re.sub(
+        "^(.{%d}).*(.{%d})$" % (prefix_len, suffix_len), "\g<1>...\g<2>", string
+    )
+
 
 # Search for common prefixes and suffixes in a list of names and return
 # a (prefix,suffix) tuple that specifies how many characters can be dropped
 # for the prefix/suffix. The numbers will be small enough that no name will
 # become shorter than min_len characters.
 def determine_common_prefix_suffix(names, min_len=8):
     if len(names) <= 1:
-        return (0,0)
+        return (0, 0)
     name0 = names[0]
     prefix = name0
     prefix_len = len(name0)
     suffix = name0
     suffix_len = len(name0)
     shortest_name = len(name0)
     for name in names:
         if len(name) < shortest_name:
             shortest_name = len(name)
         while prefix_len > 0 and name[:prefix_len] != prefix:
             prefix_len -= 1
             prefix = name0[:prefix_len]
         while suffix_len > 0 and name[-suffix_len:] != suffix:
             suffix_len -= 1
             suffix = name0[-suffix_len:]
 
-    if suffix[0] != '.' and suffix[0] != '_':
+    if suffix[0] != "." and suffix[0] != "_":
         suffix_len = 0
     suffix_len = max(0, min(shortest_name - prefix_len - min_len, suffix_len))
     prefix_len = max(0, min(shortest_name - suffix_len, prefix_len))
     return (prefix_len, suffix_len)
 
+
 def format_relative_diff(value):
     if not isinstance(value, numbers.Integral):
-        return "%4.1f%%" % (value * 100.)
+        return "%4.1f%%" % (value * 100.0)
     else:
         return "%-5d" % value
 
-def print_result(d, limit_output=True, shorten_names=True, minimal_names=False,
-                 show_diff_column=True, sortkey='diff', sort_by_abs=True,
-                 absolute_diff=False):
+
+def print_result(
+    d,
+    limit_output=True,
+    shorten_names=True,
+    minimal_names=False,
+    show_diff_column=True,
+    sortkey="diff",
+    sort_by_abs=True,
+    absolute_diff=False,
+):
     metrics = d.columns.levels[0]
     if sort_by_abs:
         d = d.sort_values(by=(metrics[0], sortkey), key=pd.Series.abs, ascending=False)
     else:
         d = d.sort_values(by=(metrics[0], sortkey), ascending=False)
 
     # Ensure that the columns are grouped by metric (rather than having the
     # diffs at the end of the line).
     d = d.reindex(columns=d.columns.levels[0], level=0)
 
     if not show_diff_column:
         # Remove all diff columns (using level=1 since level 0 is the metric).
-        d.drop(labels='diff', level=1, axis=1, inplace=True)
+        d.drop(labels="diff", level=1, axis=1, inplace=True)
     dataout = d
     if limit_output:
         # Take 15 topmost elements
         dataout = dataout.head(15)
 
     formatters = dict()
     if not absolute_diff:
         for m in metrics:
-            formatters[(m, 'diff')] = format_relative_diff
+            formatters[(m, "diff")] = format_relative_diff
     # Turn index into a column so we can format it...
     formatted_program = dataout.index.to_series()
     if shorten_names:
+
         def format_name(name, common_prefix, common_suffix):
             name = name[common_prefix:]
             if common_suffix > 0:
                 name = name[:-common_suffix]
             return "%-45s" % truncate(name, 10, 30)
 
-
         def strip_name_fully(name):
-            name = name.split('/')[-1]
-            if name.endswith('.test'):
+            name = name.split("/")[-1]
+            if name.endswith(".test"):
                 name = name[:-5]
             return name
 
         # The to_string formatters argument appears to be ignored for
         # dtype=object, so transform the program column manually.
         if minimal_names:
             formatted_program = formatted_program.map(strip_name_fully)
         else:
             drop_prefix, drop_suffix = determine_common_prefix_suffix(formatted_program)
-            formatted_program = formatted_program.map(lambda name: format_name(name, drop_prefix, drop_suffix))
-    dataout.insert(0, 'Program', formatted_program)
+            formatted_program = formatted_program.map(
+                lambda name: format_name(name, drop_prefix, drop_suffix)
+            )
+    dataout.insert(0, "Program", formatted_program)
     # Add the geometric mean row after we have formatted the program names
     # as it will otherwise interfere with common prefix/suffix computation.
     if show_diff_column and not absolute_diff:
         # geometric mean only makes sense for relative differences.
         dataout = add_geomean_row(metrics, d, dataout)
 
     def float_format(x):
-        if x == '':
-            return ''
+        if x == "":
+            return ""
         return "%6.2f" % (x,)
 
     pd.set_option("display.max_colwidth", 0)
-    pd.set_option('display.width', 0)
+    pd.set_option("display.width", 0)
     # Print an empty value instead of NaN (for the geomean row).
-    out = dataout.to_string(index=False, justify='left', na_rep='',
-                            float_format=float_format, formatters=formatters)
+    out = dataout.to_string(
+        index=False,
+        justify="left",
+        na_rep="",
+        float_format=float_format,
+        formatters=formatters,
+    )
     print(out)
     print(d.describe())
 
+
 def main():
-    parser = argparse.ArgumentParser(prog='compare.py')
-    parser.add_argument('-a', '--all', action='store_true')
-    parser.add_argument('-f', '--full', action='store_true')
-    parser.add_argument('-m', '--metric', action='append', dest='metrics',
-                        default=[])
-    parser.add_argument('--nodiff', action='store_false', dest='show_diff',
-                        default=None)
-    parser.add_argument('--diff', action='store_true', dest='show_diff')
-    parser.add_argument('--absolute-diff', action='store_true',
-                        help='Use an absolute instead of a relative difference')
-    parser.add_argument('--filter-short', nargs='?',
-                        dest='filter_short', default=None,
-                        help="Filter benchmarks with execution times less than N seconds (default 1.0s)")
-    parser.add_argument('--no-filter-failed', action='store_false',
-                        dest='filter_failed', default=True)
-    parser.add_argument('--filter-hash', action='store_true',
-                        dest='filter_hash', default=False)
-    parser.add_argument('--filter-blacklist',
-                        dest='filter_blacklist', default=None)
-    parser.add_argument('--merge-average', action='store_const',
-                        dest='merge_function', const=pd.DataFrame.mean,
-                        default=pd.DataFrame.min)
-    parser.add_argument('--merge-min', action='store_const',
-                        dest='merge_function', const=pd.DataFrame.min)
-    parser.add_argument('--merge-max', action='store_const',
-                        dest='merge_function', const=pd.DataFrame.max)
-    parser.add_argument('--lhs-name', default="lhs",
-                        help="Name used to describe left side in 'vs' mode")
-    parser.add_argument('--rhs-name', default="rhs",
-                        help="Name used to describe right side in 'vs' mode")
-    parser.add_argument('files', metavar='FILE', nargs='+', help="To compare two groups of results, put 'vs' between them")
-    parser.add_argument('--minimal-names', action='store_true',
-                        dest='minimal_names', default=False)
-    parser.add_argument('--no-abs-sort', action='store_true',
-                        dest='no_abs_sort', default=False, help="Don't use abs() when sorting results")
+    parser = argparse.ArgumentParser(prog="compare.py")
+    parser.add_argument("-a", "--all", action="store_true")
+    parser.add_argument("-f", "--full", action="store_true")
+    parser.add_argument("-m", "--metric", action="append", dest="metrics", default=[])
+    parser.add_argument(
+        "--nodiff", action="store_false", dest="show_diff", default=None
+    )
+    parser.add_argument("--diff", action="store_true", dest="show_diff")
+    parser.add_argument(
+        "--absolute-diff",
+        action="store_true",
+        help="Use an absolute instead of a relative difference",
+    )
+    parser.add_argument(
+        "--filter-short",
+        nargs="?",
+        dest="filter_short",
+        default=None,
+        help="Filter benchmarks with execution times less than N seconds (default 1.0s)",
+    )
+    parser.add_argument(
+        "--no-filter-failed", action="store_false", dest="filter_failed", default=True
+    )
+    parser.add_argument(
+        "--filter-hash", action="store_true", dest="filter_hash", default=False
+    )
+    parser.add_argument("--filter-blacklist", dest="filter_blacklist", default=None)
+    parser.add_argument(
+        "--merge-average",
+        action="store_const",
+        dest="merge_function",
+        const=pd.DataFrame.mean,
+        default=pd.DataFrame.min,
+    )
+    parser.add_argument(
+        "--merge-min",
+        action="store_const",
+        dest="merge_function",
+        const=pd.DataFrame.min,
+    )
+    parser.add_argument(
+        "--merge-max",
+        action="store_const",
+        dest="merge_function",
+        const=pd.DataFrame.max,
+    )
+    parser.add_argument(
+        "--lhs-name", default="lhs", help="Name used to describe left side in 'vs' mode"
+    )
+    parser.add_argument(
+        "--rhs-name",
+        default="rhs",
+        help="Name used to describe right side in 'vs' mode",
+    )
+    parser.add_argument(
+        "files",
+        metavar="FILE",
+        nargs="+",
+        help="To compare two groups of results, put 'vs' between them",
+    )
+    parser.add_argument(
+        "--minimal-names", action="store_true", dest="minimal_names", default=False
+    )
+    parser.add_argument(
+        "--no-abs-sort",
+        action="store_true",
+        dest="no_abs_sort",
+        default=False,
+        help="Don't use abs() when sorting results",
+    )
     config = parser.parse_args()
 
     if config.show_diff is None:
         config.show_diff = len(config.files) > 1
 
     # If only --filter-short is provided, i.e. its optional argument is
     # omitted, we default to threshold of 1 second to filter out apps and
     # results with a execution time less than that.
if config.filter_short is not None:
         except:
             config.files.insert(0, config.filter_short)
 
     # Read inputs
     files = config.files
     if "vs" in files:
         split = files.index("vs")
         lhs = files[0:split]
-        rhs = files[split+1:]
+        rhs = files[split + 1 :]
 
         # Filter minimum of lhs and rhs
         lhs_d = readmulti(lhs)
         lhs_merged = lhs_d.groupby(level=1).apply(config.merge_function)
         rhs_d = readmulti(rhs)
         rhs_merged = rhs_d.groupby(level=1).apply(config.merge_function)
 
         # Combine to new dataframe
-        data = pd.concat([lhs_merged, rhs_merged], names=['l/r'],
-                         keys=[config.lhs_name, config.rhs_name])
+        data = pd.concat(
+            [lhs_merged, rhs_merged],
+            names=["l/r"],
+            keys=[config.lhs_name, config.rhs_name],
+        )
     else:
         data = readmulti(files)
 
     # Decide which metric to display / what is our "main" metric
     metrics = config.metrics
     if len(metrics) == 0:
-        defaults = [ 'Exec_Time', 'exec_time', 'Value', 'Runtime' ]
+        defaults = ["Exec_Time", "exec_time", "Value", "Runtime"]
         for defkey in defaults:
             if defkey in data.columns:
                 metrics = [defkey]
                 break
     if len(metrics) == 0:
         sys.stderr.write("No default metric found and none specified\n")
         sys.stderr.write("Available metrics:\n")
         for column in data.columns:
             sys.stderr.write("\t%s\n" % column)
         sys.exit(1)
     for metric in metrics:
         problem = False
         if metric not in data.columns:
             sys.stderr.write("Unknown metric '%s'\n" % metric)
             problem = True
         if problem:
             sys.exit(1)
 
     # Filter data
     proggroup = data.groupby(level=1)
     initial_size = len(proggroup.indices)
     print("Tests: %s" % (initial_size,))
-    if config.filter_failed and hasattr(data, 'Exec'):
+    if config.filter_failed and hasattr(data, "Exec"):
         newdata = filter_failed(data)
         print_filter_stats("Failed", data, newdata)
-        newdata = newdata.drop('Exec', 1)
+        newdata = newdata.drop("Exec", 1)
         data = newdata
     if config.filter_short:
         newdata = filter_short(data, filter_short_threshold, metric)
         print_filter_stats("Short Running", data, newdata)
         data = newdata
-    if config.filter_hash and 'hash' in data.columns and \
-       data.index.get_level_values(0).nunique() > 1:
+    if (
+        config.filter_hash
+        and "hash" in data.columns
+        and data.index.get_level_values(0).nunique() > 1
+    ):
         newdata = filter_same_hash(data)
         print_filter_stats("Same hash", data, newdata)
         data = newdata
     if config.filter_blacklist:
         blacklist = open(config.filter_blacklist).readlines()
         blacklist = [line.strip() for line in blacklist]
         newdata = filter_blacklist(data, blacklist)
         print_filter_stats("In Blacklist", data, newdata)
         data = newdata
     final_size = len(data.groupby(level=1))
     if final_size != initial_size:
         print("Remaining: %d" % (final_size,))
 
     # Reduce / add columns
     print("Metric: %s" % (",".join(metrics),))
     if len(metrics) > 0:
         data = data[metrics]
 
     data = data.unstack(level=0)
 
     for metric in data.columns.levels[0]:
         data = add_diff_column(metric, data, absolute_diff=config.absolute_diff)
 
-    sortkey = 'diff'
+    sortkey = "diff"
     # TODO: should we still be sorting by diff even if the diff is hidden?
     if len(config.files) == 1:
         sortkey = data.columns.levels[1][0]
 
     # Print data
     print("")
     shorten_names = not config.full
     limit_output = (not config.all) and (not config.full)
-    print_result(data, limit_output, shorten_names, config.minimal_names,
-                 config.show_diff, sortkey, config.no_abs_sort,
-                 config.absolute_diff)
+    print_result(
+        data,
+        limit_output,
+        shorten_names,
+        config.minimal_names,
+        config.show_diff,
+        sortkey,
+        config.no_abs_sort,
+        config.absolute_diff,
+    )
 
 
 if __name__ == "__main__":
     main()

utils/tdiff.py

 # Ninja query code based on ninja/src/browse.py (apache license version 2.0).
 import sys
 import subprocess
 import argparse
 import os
 from collections import namedtuple
 
 
-Node = namedtuple('Node', ['inputs', 'rule', 'target', 'outputs'])
+Node = namedtuple("Node", ["inputs", "rule", "target", "outputs"])
 
 
 def match_strip(line, prefix):
     if not line.startswith(prefix):
         return (False, line)
-    return (True, line[len(prefix):])
+    return (True, line[len(prefix) :])
 
 
 def parse(text):
     text = text.strip()
-    lines = iter(text.split('\n'))
+    lines = iter(text.split("\n"))
 
     rule = None
     inputs = []
     outputs = []
 
     try:
         line = None
         while True:
             target = None
             if line is None:
                 line = next(lines)
             target = line[:-1]  # strip trailing colon
 
             line = next(lines)
-            (match, rule) = match_strip(line, '  input: ')
+            (match, rule) = match_strip(line, "  input: ")
             if match:
-                (match, line) = match_strip(next(lines), '    ')
+                (match, line) = match_strip(next(lines), "    ")
                 while match:
                     type = None
-                    (match, line) = match_strip(line, '| ')
+                    (match, line) = match_strip(line, "| ")
                     if match:
-                        type = 'implicit'
-                    (match, line) = match_strip(line, '|| ')
+                        type = "implicit"
+                    (match, line) = match_strip(line, "|| ")
                     if match:
-                        type = 'order-only'
+                        type = "order-only"
                     inputs.append((line, type))
-                    (match, line) = match_strip(next(lines), '    ')
+                    (match, line) = match_strip(next(lines), "    ")
 
-            match, _ = match_strip(line, '  outputs:')
+            match, _ = match_strip(line, "  outputs:")
             if match:
-                (match, line) = match_strip(next(lines), '    ')
+                (match, line) = match_strip(next(lines), "    ")
                 while match:
                     outputs.append(line)
-                    (match, line) = match_strip(next(lines), '    ')
+                    (match, line) = match_strip(next(lines), "    ")
             yield Node(inputs, rule, target, outputs)
     except StopIteration:
         pass
 
     if target is not None:
         yield Node(inputs, rule, target, outputs)
 
 
 def query_ninja(targets, cwd):
     # Query ninja for a node in its build dependency tree.
-    proc = subprocess.Popen(['ninja', '-t', 'query'] + targets, cwd=cwd,
-                            stdout=subprocess.PIPE, universal_newlines=True)
+    proc = subprocess.Popen(
+        ["ninja", "-t", "query"] + targets,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        universal_newlines=True,
+    )
     out, _ = proc.communicate()
     if proc.returncode != 0:
         raise Exception("Failed to query ninja for targets: %s" % (targets,))
     return parse(out)
 
 
 def determine_max_commandline_len():
     """Determine maximum length of commandline possible"""
     # See also http://www.in-ulm.de/~mascheck/various/argmax/
-    sc_arg_max = os.sysconf('SC_ARG_MAX')
+    sc_arg_max = os.sysconf("SC_ARG_MAX")
     if sc_arg_max <= 0:
-        return 10000 # wild guess
+        return 10000  # wild guess
     env_len = 0
-    for key,val in os.environ.items():
+    for key, val in os.environ.items():
         env_len += len(key) + len(val) + 10
     return sc_arg_max - env_len
 
 
 def get_inputs_rec(target, cwd):
     worklist = [target]
 
     result = dict()
while len(worklist) > 0:
                 break
             querylist.append(w)
         if querylist == []:
             break
 
         queryres = query_ninja(querylist, cwd)
         for res in queryres:
             result[res.target] = res
-            for inp,typ in res.inputs:
-                if typ == 'order-only':
+            for inp, typ in res.inputs:
+                if typ == "order-only":
                     continue
                 worklist.append(inp)
     return result
 
 
 def replace_ext(filename, newext):
     # Note that os.path.splitext() does not work here: We want '.c.o' -> '.xxx'
     dirname, basename = os.path.split(filename)
     return dirname + "/" + basename.split(".", 1)[0] + newext
 
 
 def filelist(mode, target, cwd, config):
     tree = get_inputs_rec(config.target[0], cwd)
 
-    if config.mode == 'sources':
+    if config.mode == "sources":
         # Take leafs in the dependency tree
         for target, depnode in tree.items():
             if len(depnode.inputs) == 0:
                 yield target
     else:
         # Take files ending in '.o'
         for target, depnode in tree.items():
             if target.endswith(".o"):
                 # Determine .s/.stats ending used by -save-temps=obj or
                 # -save-stats=obj
-                if config.mode == 's_files':
-                    target = replace_ext(target, '.s')
-                elif config.mode == 'stats':
-                    target = replace_ext(target, '.stats')
+                if config.mode == "s_files":
+                    target = replace_ext(target, ".s")
+                elif config.mode == "stats":
+                    target = replace_ext(target, ".stats")
                 else:
-                    assert config.mode == 'objects'
+                    assert config.mode == "objects"
                 yield target
 
 
 def diff_file(dir0, dir1, target, config):
-    u_args = ['-u']
+    u_args = ["-u"]
     if config.diff_U is not None:
-        u_args = ['-U' + config.diff_U]
+        u_args = ["-U" + config.diff_U]
     files = ["%s/%s" % (dir0, target), "%s/%s" % (dir1, target)]
-    rescode = subprocess.call(['diff'] + u_args + files)
+    rescode = subprocess.call(["diff"] + u_args + files)
     return rescode
 
 
 def main(argv):
     parser = argparse.ArgumentParser(prog=argv[0])
-    parser.add_argument('-s', '--s_files', dest='mode', action='store_const',
-                        const='s_files', help="Select assembly files")
-    parser.add_argument('-i', '--sources', dest='mode', action='store_const',
-                        const='sources', help="Select source files")
-    parser.add_argument('-o', '--objects', dest='mode', action='store_const',
-                        const='objects', help="Select object files")
-    parser.add_argument('-S', '--stats', dest='mode', action='store_const',
-                        const='stats', help="Select statistics files")
-    parser.add_argument('-a', '--dir0', dest='dir0')
-    parser.add_argument('-b', '--dir1', dest='dir1')
-    parser.add_argument('-U', dest='diff_U')
-    parser.add_argument('target', metavar='TARGET', nargs=1)
+    parser.add_argument(
+        "-s",
+        "--s_files",
+        dest="mode",
+        action="store_const",
+        const="s_files",
+        help="Select assembly files",
+    )
+    parser.add_argument(
+        "-i",
+        "--sources",
+        dest="mode",
+        action="store_const",
+        const="sources",
+        help="Select source files",
+    )
+    parser.add_argument(
+        "-o",
+        "--objects",
+        dest="mode",
+        action="store_const",
+        const="objects",
+        help="Select object files",
+    )
+    parser.add_argument(
+        "-S",
+        "--stats",
+        dest="mode",
+        action="store_const",
+        const="stats",
+        help="Select statistics files",
+    )
+    parser.add_argument("-a", "--dir0", dest="dir0")
+    parser.add_argument("-b", "--dir1", dest="dir1")
+    parser.add_argument("-U", dest="diff_U")
+    parser.add_argument("target", metavar="TARGET", nargs=1)
     config = parser.parse_args()
     if config.mode is None:
         parser.print_usage(sys.stderr)
-        sys.stderr.write("%s: error: Must specify a mode\n" % (argv[0], ))
+        sys.stderr.write("%s: error: Must specify a mode\n" % (argv[0],))
         sys.exit(1)
     if (config.dir0 is None) != (config.dir1 is None):
         sys.stderr.write("%s: error: Must specify dir0+dir1 (or none)")
         sys.exit(1)
 
     files = filelist(config.mode, config.target[0], config.dir0, config)
 
     if config.dir0:
         global_rc = 0
         for target in files:
             rc = diff_file(config.dir0, config.dir1, target, config)
             if rc != 0:
                 global_rc = rc
         sys.exit(global_rc)
     else:
         # Simply print file list
         for f in files:
             print(f)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv)