#!/usr/bin/env python #------------------------------------------------------------------------------- # test/run_readelf_tests.py # # Automatic test runner for elftools & readelf # # Eli Bendersky (eliben@gmail.com) # This code is in the public domain #------------------------------------------------------------------------------- import argparse from difflib import SequenceMatcher import logging from multiprocessing import Pool import os import platform import re import sys import time from utils import run_exe, is_in_rootdir, dump_output_to_temp_files # Make it possible to run this file from the root dir of pyelftools without # installing pyelftools; useful for Travis testing, etc. sys.path[0:0] = ['.'] # Create a global logger object testlog = logging.getLogger('run_tests') testlog.setLevel(logging.DEBUG) testlog.addHandler(logging.StreamHandler(sys.stdout)) # Set the path for calling readelf. We carry our own version of readelf around, # because binutils tend to change its output even between daily builds of the # same minor release and keeping track is a headache. if platform.system() == "Darwin": # MacOS READELF_PATH = 'greadelf' else: READELF_PATH = 'test/external_tools/readelf' if not os.path.exists(READELF_PATH): READELF_PATH = 'readelf' def discover_testfiles(rootdir): """ Discover test files in the given directory. Yield them one by one. """ for filename in os.listdir(rootdir): _, ext = os.path.splitext(filename) if ext == '.elf': yield os.path.join(rootdir, filename) def run_test_on_file(filename, verbose=False): """ Runs a test on the given input filename. Return True if all test runs succeeded. """ success = True testlog.info("Test file '%s'" % filename) for option in [ '-e', '-d', '-s', '-n', '-r', '-x.text', '-p.shstrtab', '-V', '--debug-dump=info', '--debug-dump=decodedline', '--debug-dump=frames', '--debug-dump=frames-interp', '--debug-dump=aranges']: if verbose: testlog.info("..option='%s'" % option) # TODO(zlobober): this is a dirty hack to make tests work for ELF core # dump notes. Making it work properly requires a pretty deep # investigation of how original readelf formats the output. if "core" in filename and option == "-n": if verbose: testlog.warning("....will fail because corresponding part of readelf.py is not implemented yet") testlog.info('.......................SKIPPED') continue # stdouts will be a 2-element list: output of readelf and output # of scripts/readelf.py stdouts = [] for exe_path in [READELF_PATH, 'scripts/readelf.py']: args = [option, filename] if verbose: testlog.info("....executing: '%s %s'" % ( exe_path, ' '.join(args))) t1 = time.time() rc, stdout = run_exe(exe_path, args) if verbose: testlog.info("....elapsed: %s" % (time.time() - t1,)) if rc != 0: testlog.error("@@ aborting - '%s' returned '%s'" % (exe_path, rc)) return False stdouts.append(stdout) if verbose: testlog.info('....comparing output...') t1 = time.time() rc, errmsg = compare_output(*stdouts) if verbose: testlog.info("....elapsed: %s" % (time.time() - t1,)) if rc: if verbose: testlog.info('.......................SUCCESS') else: success = False testlog.info('.......................FAIL') testlog.info('....for option "%s"' % option) testlog.info('....Output #1 is readelf, Output #2 is pyelftools') testlog.info('@@ ' + errmsg) dump_output_to_temp_files(testlog, *stdouts) return success def compare_output(s1, s2): """ Compare stdout strings s1 and s2. s1 is from readelf, s2 from elftools readelf.py Return pair success, errmsg. If comparison succeeds, success is True and errmsg is empty. Otherwise success is False and errmsg holds a description of the mismatch. Note: this function contains some rather horrible hacks to ignore differences which are not important for the verification of pyelftools. This is due to some intricacies of binutils's readelf which pyelftools doesn't currently implement, features that binutils doesn't support, or silly inconsistencies in the output of readelf, which I was reluctant to replicate. Read the documentation for more details. """ def prepare_lines(s): return [line for line in s.lower().splitlines() if line.strip() != ''] lines1 = prepare_lines(s1) lines2 = prepare_lines(s2) flag_after_symtable = False if len(lines1) != len(lines2): return False, 'Number of lines different: %s vs %s' % ( len(lines1), len(lines2)) for i in range(len(lines1)): if 'symbol table' in lines1[i]: flag_after_symtable = True # Compare ignoring whitespace lines1_parts = lines1[i].split() lines2_parts = lines2[i].split() if ''.join(lines1_parts) != ''.join(lines2_parts): ok = False try: # Ignore difference in precision of hex representation in the # last part (i.e. 008f3b vs 8f3b) if (''.join(lines1_parts[:-1]) == ''.join(lines2_parts[:-1]) and int(lines1_parts[-1], 16) == int(lines2_parts[-1], 16)): ok = True except ValueError: pass sm = SequenceMatcher() sm.set_seqs(lines1[i], lines2[i]) changes = sm.get_opcodes() if flag_after_symtable: # Detect readelf's adding @ with lib and version after # symbol name. if ( len(changes) == 2 and changes[1][0] == 'delete' and lines1[i][changes[1][1]] == '@'): ok = True elif 'at_const_value' in lines1[i]: # On 32-bit machines, readelf doesn't correctly represent # some boundary LEB128 numbers val = lines2_parts[-1] num2 = int(val, 16 if val.startswith('0x') else 10) if num2 <= -2**31 and '32' in platform.architecture()[0]: ok = True elif 'os/abi' in lines1[i]: if 'unix - gnu' in lines1[i] and 'unix - linux' in lines2[i]: ok = True elif ( 'unknown at value' in lines1[i] and 'dw_at_apple' in lines2[i]): ok = True else: for s in ('t (tls)', 'l (large)'): if s in lines1[i] or s in lines2[i]: ok = True break if not ok: errmsg = 'Mismatch on line #%s:\n>>%s<<\n>>%s<<\n (%r)' % ( i, lines1[i], lines2[i], changes) return False, errmsg return True, '' def main(): if not is_in_rootdir(): testlog.error('Error: Please run me from the root dir of pyelftools!') return 1 argparser = argparse.ArgumentParser( usage='usage: %(prog)s [options] [file] [file] ...', prog='run_readelf_tests.py') argparser.add_argument('files', nargs='*', help='files to run tests on') argparser.add_argument( '--parallel', action='store_true', help='run tests in parallel; always runs all tests w/o verbose') argparser.add_argument('-V', '--verbose', action='store_true', dest='verbose', help='verbose output') argparser.add_argument( '-k', '--keep-going', action='store_true', dest='keep_going', help="Run all tests, don't stop at the first failure") args = argparser.parse_args() if args.parallel: if args.verbose or args.keep_going == False: print('WARNING: parallel mode disables verbosity and always keeps going') if args.verbose: testlog.info('Running in verbose mode') testlog.info('Python executable = %s' % sys.executable) testlog.info('readelf path = %s' % READELF_PATH) testlog.info('Given list of files: %s' % args.files) # If file names are given as command-line arguments, only these files # are taken as inputs. Otherwise, autodiscovery is performed. if len(args.files) > 0: filenames = args.files else: filenames = sorted(discover_testfiles('test/testfiles_for_readelf')) if len(filenames) > 1 and args.parallel: pool = Pool() results = pool.map( run_test_on_file, filenames) failures = results.count(False) else: failures = 0 for filename in filenames: if not run_test_on_file(filename, verbose=args.verbose): failures += 1 if not args.keep_going: break if failures == 0: testlog.info('\nConclusion: SUCCESS') return 0 elif args.keep_going: testlog.info('\nConclusion: FAIL ({}/{})'.format( failures, len(filenames))) return 1 else: testlog.info('\nConclusion: FAIL') return 1 if __name__ == '__main__': sys.exit(main())