diff --git a/test/compareheuristics.py b/test/compareheuristics.py index 16e0025..020945e 100755 --- a/test/compareheuristics.py +++ b/test/compareheuristics.py @@ -1,6 +1,6 @@ #!/usr/bin/python # -# Compare heuristics +# Compare heuristics # import sys from optparse import OptionParser @@ -9,169 +9,173 @@ import scythertest # Parse def parse(scout): - """Parse Scyther output for heuristics tests + """Parse Scyther output for heuristics tests - in: - A single Scyther output string (including newlines) - out: - ra: number of failed claims - rb: number of bounded proofs of claims - rc: number of complete proofs of claims - nc: number of processed claims (should be the sum of the previous) - st: number of states traversed - """ - - ra = 0 - rb = 0 - rp = 0 - nc = 0 - st = 0 - for l in scout.splitlines(): - data = l.split() - if len(data) > 6 and data[0] == 'claim': - tag = data[6] - if tag == 'failed:': - ra = ra + 1 - nc = nc + 1 - elif tag == 'correct:': - nc = nc + 1 - if l.rfind("complete_proof") != -1: - rp = rp + 1 - else: - rb = rb + 1 - elif data[0] == 'states': - st = int(data[1]) - return (ra,rb,rp,nc,st) + in: + A single Scyther output string (including newlines) + out: + ra: number of failed claims + rb: number of bounded proofs of claims + rc: number of complete proofs of claims + nc: number of processed claims (should be the sum of the previous) + st: number of states traversed + """ + + ra = 0 + rb = 0 + rp = 0 + nc = 0 + st = 0 + for l in scout.splitlines(): + data = l.split() + if len(data) > 4 and data[0] == 'claim': + # determine claim status + tag = data[4] + if tag == 'Fail': + ra = ra + 1 + nc = nc + 1 + elif tag == 'Ok': + nc = nc + 1 + if l.rfind("proof of correctness") != -1: + rp = rp + 1 + else: + rb = rb + 1 + # now count the states + for d in data: + if d.startswith("states="): + st = st + int(d[7:]) + + return (ra,rb,rp,nc,st) def test_goal_selector(goalselector, options): - """Test with a given goal selector + """Test with a given goal selector - in: - goalselector: as in Scyther docs. - options: options record (formatted as in optparse module) - out: - (attacks,bounds,proofs,claims,np,states) - attacks: number of failed claims - bounds: number of bounded proofs - proofs: number of complete proofs - np: number of protocols tested - states: total number of states explored. - """ + in: + goalselector: as in Scyther docs. + options: options record (formatted as in optparse module) + out: + (attacks,bounds,proofs,claims,np,states) + attacks: number of failed claims + bounds: number of bounded proofs + proofs: number of complete proofs + np: number of protocols tested + states: total number of states explored. + """ - import protocollist + import protocollist - scythertest.set_extra_parameters("--goal-select=" + str(goalselector)) - result = str(goalselector) - plist = protocollist.from_literature() - np = len(plist) + scythertest.set_extra_parameters("--count-states --heuristic=" + str(goalselector)) + result = str(goalselector) + plist = protocollist.from_literature() + np = len(plist) - attacks = 0 - bounds = 0 - proofs = 0 - claims = 0 - states = 0 - for p in plist: - (status,scout) = scythertest.default_test([p], \ - int(options.match), \ - int(options.bounds)) - (ra,rb,rp,nc,st) = parse(scout) - attacks = attacks + ra - bounds = bounds + rb - proofs = proofs + rp - claims = claims + nc - states = states + st - - return (attacks,bounds,proofs,claims,np,states) + attacks = 0 + bounds = 0 + proofs = 0 + claims = 0 + states = 0 + for p in plist: + (status,scout) = scythertest.default_test([p], \ + int(options.match), \ + int(options.bounds)) + (ra,rb,rp,nc,st) = parse(scout) + attacks = attacks + ra + bounds = bounds + rb + proofs = proofs + rp + claims = claims + nc + states = states + st + + return (attacks,bounds,proofs,claims,np,states) # Max class maxor: - """Class for a dynamic maximum determination and corresponding formatting - """ + """Class for a dynamic maximum determination and corresponding formatting + """ - def __init__(self,dir=0,mymin=99999999, mymax=-99999999): - """Init + def __init__(self,dir=0,mymin=99999999, mymax=-99999999): + """Init - in: - dir: bit 0 is set : notify of increase - bit 1 is set : notify of decrease - mymin: initial minimum - mymax: initial maximum - """ + in: + dir: bit 0 is set : notify of increase + bit 1 is set : notify of decrease + mymin: initial minimum + mymax: initial maximum + """ - self.dir = dir - self.min = mymin - self.max = mymax - - def reg(self,data): - """Store a new data element + self.dir = dir + self.min = mymin + self.max = mymax + + def reg(self,data): + """Store a new data element - in: - element to be stored - out: - formatted element, plus increase/decrease - notifications according to initial settings. - """ + in: + element to be stored + out: + formatted element, plus increase/decrease + notifications according to initial settings. + """ - res = "" - if self.min >= data: - self.min = data - if (self.dir & 2): - res = res + "-" - if self.max <= data: - self.max = data - if (self.dir & 1): - res = res + "+" - if res == "": - return res - else: - return "[" + res + "]" + res = "" + if self.min >= data: + self.min = data + if (self.dir & 2): + res = res + "-" + if self.max <= data: + self.max = data + if (self.dir & 1): + res = res + "+" + if res == "": + return res + else: + return "[" + res + "]" # Main code def main(): - parser = OptionParser() - scythertest.default_options(parser) - (options, args) = parser.parse_args() - scythertest.process_default_options(options) + parser = OptionParser() + scythertest.default_options(parser) + (options, args) = parser.parse_args() + scythertest.process_default_options(options) - print "G-sel\tAttack\tBound\tProof\tClaims\tScore1\tScore2\tStates\tBnd*Sts" - print + print "G-sel\tAttack\tBound\tProof\tClaims\tScore1\tScore2\tStates\tBnd*Sts" + print - ramax = maxor(1) - rbmax = maxor(2) - rpmax = maxor(1) - score1max = maxor(1) - score2max = maxor(1) - statesmax = maxor(2) - boundstatesmax = maxor(2) + ramax = maxor(1) + rbmax = maxor(2) + rpmax = maxor(1) + score1max = maxor(1) + score2max = maxor(1) + statesmax = maxor(2) + boundstatesmax = maxor(2) - for g in range(1,31): - if (g & 8) == 0: - (ra,rb,rp,nc,np,st) = test_goal_selector(g, options) + for g in range(1,63): + if (g & 8) == 0 and (g & 4) == 0 : + (ra,rb,rp,nc,np,st) = test_goal_selector(g, options) - # Scores: bounds are negative - score1 = ra + rp - rb - score2 = ra + (3 * rp) - (2 * rb) - boundstates = rb * st + # Scores: bounds are negative + score1 = ra + rp - rb + score2 = ra + (3 * rp) - (2 * rb) + boundstates = rb * st - res = str(g) + res = str(g) - def shows (res, mx, data): - return res + "\t" + str(data) + mx.reg(data) + def shows (res, mx, data): + return res + "\t" + str(data) + mx.reg(data) - res = shows (res, ramax, ra) - res = shows (res, rbmax, rb) - res = shows (res, rpmax, rp) - res = res + "\t" + str(nc) - res = shows (res, score1max, score1) - res = shows (res, score2max, score2) - res = shows (res, statesmax, st) - res = shows (res, boundstatesmax, boundstates) + res = shows (res, ramax, ra) + res = shows (res, rbmax, rb) + res = shows (res, rpmax, rp) + res = res + "\t" + str(nc) + res = shows (res, score1max, score1) + res = shows (res, score2max, score2) + res = shows (res, statesmax, st) + res = shows (res, boundstatesmax, boundstates) - print res - print - print "Goal selector scan completed." + print res + print + print "Goal selector scan completed." # Only if main stuff if __name__ == '__main__': - main() + main() diff --git a/test/protocollist.py b/test/protocollist.py index ff57066..a10775e 100644 --- a/test/protocollist.py +++ b/test/protocollist.py @@ -1,98 +1,105 @@ #!/usr/bin/python # -# protocol list +# protocol list # # +import os; + def list_ppfix(list, prefix, postfix): - newlist = [] - for i in list: - newlist.append(prefix + i + postfix) - return newlist + return [ prefix + i + postfix for i in list] def from_good_literature(): - list = [ \ - "ccitt509-1c.spdl", - "ccitt509-1.spdl", - "ccitt509-3.spdl", - "ccitt509-ban3.spdl", - "denning-sacco-lowe.spdl", - "denning-sacco.spdl", - "kaochow.spdl", - "kaochow-v2.spdl", - "kaochow-v3.spdl", - "ksl-lowe.spdl", - "ksl.spdl", - "needham-schroeder-lowe.spdl", - "needham-schroeder-sk-amend.spdl", - "needham-schroeder-sk.spdl", - "neumannstub-hwang.spdl", - "neumannstub.spdl", - "otwayrees.spdl", - "smartright.spdl", - "splice-as-cj.spdl", - "splice-as-hc.spdl", - "splice-as.spdl", - "woo-lam-pi-f.spdl", - "woo-lam-pi.spdl", - "woo-lam.spdl", - "yahalom-lowe.spdl", - "yahalom-paulson.spdl" ] + list = [ \ + "ccitt509-1c.spdl", + "ccitt509-1.spdl", + "ccitt509-3.spdl", + "ccitt509-ban3.spdl", + "denning-sacco-lowe.spdl", + "denning-sacco.spdl", + "kaochow.spdl", + "kaochow-v2.spdl", + "kaochow-v3.spdl", + "ksl-lowe.spdl", + "ksl.spdl", + "needham-schroeder-lowe.spdl", + "needham-schroeder-sk-amend.spdl", + "needham-schroeder-sk.spdl", + "neumannstub-hwang.spdl", + "neumannstub.spdl", + "otwayrees.spdl", + "smartright.spdl", + "splice-as-cj.spdl", + "splice-as-hc.spdl", + "splice-as.spdl", + "woo-lam-pi-f.spdl", + "woo-lam-pi.spdl", + "woo-lam.spdl", + "yahalom-lowe.spdl", + "yahalom-paulson.spdl" ] - return list_ppfix(list, "../spdl/SPORE/","") + return list_ppfix(list, "/home/cas/svn/ecss/protocols/spdl/SPORE/","") def from_bad_literature(): - list = [ \ - "andrew-ban-concrete.spdl", - "andrew-ban.spdl", - "andrew-lowe-ban.spdl", - "andrew.spdl", - "needham-schroeder.spdl", - "tmn.spdl", - "wmf-lowe.spdl", - "wmf.spdl", - "woo-lam-pi-1.spdl", - "woo-lam-pi-2.spdl", - "woo-lam-pi-3.spdl", - "yahalom-ban.spdl", - "yahalom.spdl" ] + list = [ \ + "andrew-ban-concrete.spdl", + "andrew-ban.spdl", + "andrew-lowe-ban.spdl", + "andrew.spdl", + "needham-schroeder.spdl", + "tmn.spdl", + "wmf-lowe.spdl", + "wmf.spdl", + "woo-lam-pi-1.spdl", + "woo-lam-pi-2.spdl", + "woo-lam-pi-3.spdl", + "yahalom-ban.spdl", + "yahalom.spdl" ] - return list_ppfix(list, "../spdl/SPORE/","") + return list_ppfix(list, "/home/cas/svn/ecss/protocols/spdl/SPORE/","") def from_literature(): - return from_good_literature() + from_bad_literature() + + def spdlfiletype (fn): + return fn.endswith(".spdl") + + spdldir = "/home/cas/svn/ecss/protocols/spdl/SPORE/" + sl = os.listdir (spdldir) + sld = [ spdldir + i for i in filter (spdlfiletype, sl)] + ##print sld + return sld def from_others(): - list = [ \ - ] + list = [ \ + ] - return list_ppfix(list, "../spdl/","") + return list_ppfix(list, "../spdl/","") def from_all(): - return from_literature() + from_others() + return from_literature() + from_others() def select(type): - n = int(type) - if n == 0: - # 0 means all protocols - return from_all() - elif n == 1: - # 1 means from literature - return from_literature() - elif n == 2: - # 2 means from literature, no known attacks - return from_good_literature() - else: - # Otherwise empty list - return [] + n = int(type) + if n == 0: + # 0 means all protocols + return from_all() + elif n == 1: + # 1 means from literature + return from_literature() + elif n == 2: + # 2 means from literature, no known attacks + return from_good_literature() + else: + # Otherwise empty list + return [] def main(): - for l in [from_literature(), from_others()]: - for p in l: - print p - print + for l in [from_literature(), from_others()]: + for p in l: + print p + print if __name__ == '__main__': - main() + main() diff --git a/test/scythertest.py b/test/scythertest.py index dd058d6..85ea7d0 100755 --- a/test/scythertest.py +++ b/test/scythertest.py @@ -1,8 +1,8 @@ #!/usr/bin/python # -# Scyther wrapper +# Scyther wrapper # -# Standard tests +# Standard tests # import sys from optparse import OptionParser @@ -20,29 +20,29 @@ g_extra = "" # status def error_status(status): - if status == 1 or status < 0: - return True - else: - return False + if status == 1 or status < 0: + return True + else: + return False # Parse output def parse(scout): - results = {} - lines = scout.splitlines() - for line in lines: - data = line.split() - if len(data) > 6 and data[0] == 'claim': - claim = " ".join(data[1:4]) - tag = data[6] - value = -1 - if tag == 'failed:': - value = 0 - if tag == 'correct:': - value = 1 - if value == -1: - raise IOError, 'Scyther output for ' + commandline + ', line ' + line + ' cannot be parsed.' - results[claim] = value - return results + results = {} + lines = scout.splitlines() + for line in lines: + data = line.split() + if len(data) > 4 and data[0] == 'claim': + claim = ",".join(data[1:2]) + tag = data[5] + value = -1 + if tag == 'Fail': + value = 0 + if tag == 'Ok': + value = 1 + if value == -1: + raise IOError, 'Scyther output for ' + commandline + ', line ' + line + ' cannot be parsed.' + results[claim] = value + return results #---------------------------------------------------------------------------- # Default tests @@ -50,131 +50,131 @@ def parse(scout): # Yield default protocol list (from any other one) def default_protocols(plist): - plist.sort() - return ['../spdl/spdl-defaults.inc'] + plist + plist.sort() + return ['/home/cas/svn/ecss/protocols/spdl/spdl-defaults.inc'] + plist # Get the extra parameters def get_extra_parameters(): - global g_extra + global g_extra - return g_extra + return g_extra # Set the extra parameters def set_extra_parameters(args): - global g_extra + global g_extra - g_extra = args + g_extra = args # Add the extra parameters def add_extra_parameters(args): - global g_extra + global g_extra - if args != "": - if g_extra != "": - g_extra = g_extra + " " - g_extra = g_extra + args + if args != "": + if g_extra != "": + g_extra = g_extra + " " + g_extra = g_extra + args # Yield arguments, given a bound type: -# 0: fast -# 1: thorough +# 0: fast +# 1: thorough # def default_arguments(plist,match,bounds): - n = 2 + bounds - # These bounds assume at least two protocols, otherwise - # stuff breaks. - if n < 2: - nmin = 2 - else: - nmin = n - timer = 1 - maxruns = 2 - maxlength = 10 - if bounds == 0: - timer = 10 * (nmin**2) - maxruns = 2*nmin - maxlength = 2 + maxruns * 4 - elif bounds == 1: - timer = 10 * (nmin**3) - maxruns = 3*nmin - maxlength = 4 + maxruns * 6 - elif bounds == 2: - timer = 20 * 60 # 20 minutes - maxruns = 3*nmin - maxlength = 4 + maxruns * 6 - else: - print "Don't know bounds method", bounds - sys.exit() + n = 2 + bounds + # These bounds assume at least two protocols, otherwise + # stuff breaks. + if n < 2: + nmin = 2 + else: + nmin = n + timer = 1 + maxruns = 2 + maxlength = 10 + if bounds == 0: + timer = 10 * (nmin**2) + maxruns = 2*nmin + maxlength = 2 + maxruns * 4 + elif bounds == 1: + timer = 10 * (nmin**3) + maxruns = 3*nmin + maxlength = 4 + maxruns * 6 + elif bounds == 2: + timer = 20 * 60 # 20 minutes + maxruns = 3*nmin + maxlength = 4 + maxruns * 6 + else: + print "Don't know bounds method", bounds + sys.exit() - args = "--arachne" - if timer > 0: - args = args + " --timer=%i" % timer - args = args + " --max-runs=%i --max-length=%i" % (maxruns, maxlength) - matching = "--match=" + str(match) - args = "--summary " + matching + " " + args + args = "" + if timer > 0: + args = args + " --timer=%i" % timer + args = args + " --max-runs=%i --max-length=%i" % (maxruns, maxlength) + matching = "--match=" + str(match) + args = "--plain " + matching + " " + args - extra = get_extra_parameters() - if extra != "": - args = extra + " " + args - return args + extra = get_extra_parameters() + if extra != "": + args = extra + " " + args + return args # Yield test results def default_test(plist, match, bounds): - pl = default_protocols(plist) - args = default_arguments(plist,match,bounds) + pl = default_protocols(plist) + args = default_arguments(plist,match,bounds) - input = "" - for fn in pl: - if len(fn) > 0: - f = open(fn, "r") - input = input + f.read() - f.close() - - # Use Scyther - (status,scout) = evaluate(args,input) - return (status,scout) + input = "" + for fn in pl: + if len(fn) > 0: + f = open(fn, "r") + input = input + f.read() + f.close() + + # Use Scyther + (status,scout) = evaluate(args,input) + return (status,scout) # Test, check for status, yield parsed results def default_parsed(plist, match, bounds): - (status,scout) = default_test(plist, match, bounds) - if error_status(status): - # Something went wrong - print "*** Error when checking [", plist, match, bounds, "]" - print - sys.exit() - return parse(scout) + (status,scout) = default_test(plist, match, bounds) + if error_status(status): + # Something went wrong + print "*** Error when checking [", plist, match, bounds, "]" + print + sys.exit() + return parse(scout) # Some default options for the scyther wrapper def default_options(parser): - parser.add_option("-m","--match", dest="match", - default = 0, - help = "select matching method (0: no type flaws, 2: \ - full type flaws") - parser.add_option("-b","--bounds", dest="bounds", - default = 0, - help = "bound type selection (0: quickscan, 1:thorough, 2: no time limit)") - parser.add_option("-x","--extra", dest="extra", - default = "", - help = "add arguments to pass to Scyther") - parser.add_option("-P","--program", dest="program", - default = "", - help = "define alternative scyther executable") - parser.add_option("-N","--no-cache", dest="nocache", - default = False, - action = "store_true", - help = "do not use cache mechanism") + parser.add_option("-m","--match", dest="match", + default = 0, + help = "select matching method (0: no type flaws, 2: \ + full type flaws") + parser.add_option("-b","--bounds", dest="bounds", + default = 0, + help = "bound type selection (0: quickscan, 1:thorough, 2: no time limit)") + parser.add_option("-x","--extra", dest="extra", + default = "", + help = "add arguments to pass to Scyther") + parser.add_option("-P","--program", dest="program", + default = "", + help = "define alternative scyther executable") + parser.add_option("-N","--no-cache", dest="nocache", + default = False, + action = "store_true", + help = "do not use cache mechanism") # Process the default options def process_default_options(options): - if options.program != "": - scytheroverride(options.program) - print "Using", options.program, "as Scyther executable." - if options.extra != "": - add_extra_parameters(options.extra) - print "Added extra options, now:", get_extra_parameters() - if options.nocache: - # Do not use cache - print "Warning: Disabling cache" - cacheoverride () + if options.program != "": + scytheroverride(options.program) + print "Using", options.program, "as Scyther executable." + if options.extra != "": + add_extra_parameters(options.extra) + print "Added extra options, now:", get_extra_parameters() + if options.nocache: + # Do not use cache + print "Warning: Disabling cache" + cacheoverride () #---------------------------------------------------------------------------- @@ -182,131 +182,131 @@ def process_default_options(options): #---------------------------------------------------------------------------- def all_unless_given(plist): - if plist == []: - # Get the list - import protocollist - return protocollist.from_all() - else: - return plist + if plist == []: + # Get the list + import protocollist + return protocollist.from_all() + else: + return plist -# Scan for compilation errors or stuff like that +# Scan for compilation errors or stuff like that def scan_for_results(options,args): - # Select specific list - plist = all_unless_given(args) - # Now check all things in the list - for p in plist: - # Test and gather output - (status,scout) = default_test([p], 0, 0) - print scout + # Select specific list + plist = all_unless_given(args) + # Now check all things in the list + for p in plist: + # Test and gather output + (status,scout) = default_test([p], 0, 0) + print scout - print - print "Scan complete." + print + print "Scan complete." def scan_for_errors(options,args): - # Select specific list - plist = all_unless_given(args) - # Now check all things in the list - errorcount = 0 - for p in plist: - # Test and gather output - (status,scout) = default_test([p], 0, 0) - error = False - if error_status(status): - error = True - else: - if scout.rfind("ERROR") != -1: - error = True - if scout.rfind("error") != -1: - error = True - if error: - print "There is an error in the output for", p - errorcount = errorcount + 1 + # Select specific list + plist = all_unless_given(args) + # Now check all things in the list + errorcount = 0 + for p in plist: + # Test and gather output + (status,scout) = default_test([p], 0, 0) + error = False + if error_status(status): + error = True + else: + if scout.rfind("ERROR") != -1: + error = True + if scout.rfind("error") != -1: + error = True + if error: + print "There is an error in the output for", p + errorcount = errorcount + 1 - if errorcount > 0: - print - print "Scan complete. Found", errorcount, "error(s) in", len(plist), "files." + if errorcount > 0: + print + print "Scan complete. Found", errorcount, "error(s) in", len(plist), "files." -# Scan for timeout protocols +# Scan for timeout protocols # -# The idea is that some things will generate a timeout, and we would like -# to know which ones. However, this can just be a problem of the time -# limit, and might not be caused by a loop at all. Therefore, some -# scanning is needed. +# The idea is that some things will generate a timeout, and we would like +# to know which ones. However, this can just be a problem of the time +# limit, and might not be caused by a loop at all. Therefore, some +# scanning is needed. def scan_for_timeouts(options,args): - def parse_timeout(status,scout): - if not error_status(status): - if scout.rfind("time=") != -1: - return True - return False + def parse_timeout(status,scout): + if not error_status(status): + if scout.rfind("time=") != -1: + return True + return False - def check_for_timeout(p): - # First a simple test - (status,scout) = default_test([p], 0, 1) - if not parse_timeout(status,scout): - # Well if there is no timeout here... - return False + def check_for_timeout(p): + # First a simple test + (status,scout) = default_test([p], 0, 1) + if not parse_timeout(status,scout): + # Well if there is no timeout here... + return False - # More testing... - - return True + # More testing... + + return True - # Select specific list - plist = all_unless_given(args) - # Now check all things in the list - errorcount = 0 - for p in plist: - # Test and gather output - if check_for_timeout(p): - print "There is a timeout for", p - errorcount = errorcount + 1 + # Select specific list + plist = all_unless_given(args) + # Now check all things in the list + errorcount = 0 + for p in plist: + # Test and gather output + if check_for_timeout(p): + print "There is a timeout for", p + errorcount = errorcount + 1 - if errorcount > 0: - print - print "Scan complete. Found", errorcount, "timeout(s) in", len(plist), "files." + if errorcount > 0: + print + print "Scan complete. Found", errorcount, "timeout(s) in", len(plist), "files." #---------------------------------------------------------------------------- # Standalone usage #---------------------------------------------------------------------------- def main(): - parser = OptionParser() - default_options(parser) - parser.add_option("-e","--errors", dest="errors", - default = False, - action = "store_true", - help = "detect compilation errors for all protocols [in list_all]") - parser.add_option("-r","--results", dest="results", - default = False, - action = "store_true", - help = "scan for results for all protocols [in list_all]") - parser.add_option("-t","--timeouts", dest="timeouts", - default = False, - action = "store_true", - help = "scan for timeout errors for all protocols [in list_all]") - (options, args) = parser.parse_args() + parser = OptionParser() + default_options(parser) + parser.add_option("-e","--errors", dest="errors", + default = False, + action = "store_true", + help = "detect compilation errors for all protocols [in list_all]") + parser.add_option("-r","--results", dest="results", + default = False, + action = "store_true", + help = "scan for results for all protocols [in list_all]") + parser.add_option("-t","--timeouts", dest="timeouts", + default = False, + action = "store_true", + help = "scan for timeout errors for all protocols [in list_all]") + (options, args) = parser.parse_args() - # Globals - process_default_options(options) + # Globals + process_default_options(options) - # Subcases - if options.errors: - scan_for_errors(options,args) - elif options.results: - scan_for_results(options,args) - elif options.timeouts: - scan_for_timeouts(options,args) - else: - # Not any other switch: just test the list then - if args == []: - print "Scyther default test needs at least one input file." - sys.exit() - (status,scout) = default_test(args, options.match, options.bounds) - print "Status:", status - print scout + # Subcases + if options.errors: + scan_for_errors(options,args) + elif options.results: + scan_for_results(options,args) + elif options.timeouts: + scan_for_timeouts(options,args) + else: + # Not any other switch: just test the list then + if args == []: + print "Scyther default test needs at least one input file." + sys.exit() + (status,scout) = default_test(args, options.match, options.bounds) + print "Status:", status + print scout # Only if main stuff if __name__ == '__main__': - main() + main()