def test_fuzzy_match(self): """Tests that arrays containing different elements, where neither is a slice of the other, match if their elements are numerically close together.""" self.assertTrue(comparator.compare(self.arr1, self.arr3, MFCC_MATCH_THRESHOLD)) self.assertTrue(comparator.compare(self.arr3, self.arr1, MFCC_MATCH_THRESHOLD))
def execute(self): """ Execute the Test Case """ logger.info('Executing Test Case {}'.format(self.name)) source_writer = ResultWriter(self.name, 'source') target_writer = ResultWriter(self.name, 'target') source_records = self.source_connection.execute_query( self.source_query, source_writer.write, self.sort_source) target_records = self.target_connection.execute_query( self.target_query, target_writer.write, self.sort_target) source_mismatch, target_mismatch = comparator.compare( source_records, target_records, max_mismatch_size=self.max_mismatch_size) test_result = TestResult(self.name, self.source_query, self.target_query, source_mismatch, target_mismatch) source_writer.close() target_writer.close() logger.info('Executed Test Case {}'.format(self.name)) return test_result
def run_testcase(i, exec_file, username, qid, user_attempts, JS): in_file = "{}/question{}/input{}.txt".format(input_dir, qid, i + 1) in_file_fd = open(in_file, "r") user_out = '{}/{}/question{}/output{}{}.txt'.format( path, username, qid, user_attempts, i + 1) user_out_fd = os.open(user_out, os.O_RDWR | os.O_CREAT) # user output after running des_file = "{}/{}/{}.txt".format(des_dir, qid, str(i)) # descrption file memory and time des_fd = open(des_file, "r") lines = des_fd.readlines() time = lines[0].strip() mem = lines[1].strip() # memory des_fd.close() res = sandy_func(exec_file, in_file_fd, user_out_fd, time, mem) # stores the code in_file_fd.close() os.close(user_out_fd) expected_out = "{}/question{}/expected_output{}.txt".format( output_dir, qid, i + 1) if res == 1: # if success compile then compare outputs res = compare(i, user_out, expected_out, JS) return res
def run_testcase(i, exec_file, uid, qid): in_file = input_dir + "/" + str(qid) + "/" + str( i) + ".in" # standard input for running in_file_fd = open(in_file, "r") user_out = user_dir + "/" + str(uid) + "/" + str(qid) + "/" + str( i) + ".uout" user_out_fd = os.open(user_out, os.O_RDWR | os.O_CREAT) # user output after running des_file = description_dir + "/" + str(qid) + "/" + str( i) + ".txt" # description file des_fd = open(des_file, "r") lines = des_fd.readlines() time = lines[0].strip() mem = lines[1].strip() des_fd.close() res = sandy_func(exec_file, in_file_fd, user_out_fd, time, mem) in_file_fd.close() os.close(user_out_fd) actual_out = output_dir + "/" + qid + "/" + str(i) + ".out" if (res == 1): res = compare(user_out, actual_out) # print res os.remove(user_out) # removing user output return res
def run_test(protomol_path, conf_file, pwd): tests = 0 testspassed = 0 testsfailed = 0 failedtests = [] conf_param_overrides = parse_params(conf_file) epsilon = conf_param_overrides.get("epsilon", DEFAULT_EPSILON) scaling_factor = conf_param_overrides.get("scaling_factor", DEFAULT_SCALINGFACTOR) base = os.path.splitext(os.path.basename(conf_file))[0] logging.info("Executing Test: " + base) cmd = protomol_path[:] cmd.append(conf_file) p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = p.communicate() if p.returncode > 0: s = "Not able to execute Protomol!\n" s += "cmd: " + str(cmd) + "\n" s += "stdout: " + stdout + "\n" s += "stderr: " + stderr + "\n" logging.critical(s) expects = [] outputs = glob.glob("tests/output/" + base + ".*") outputtemp = [] for output in outputs: outbase = os.path.basename(output) if os.path.exists("tests/expected/" + outbase): outputtemp.append(output) expects.append("tests/expected/" + outbase) outputs = outputtemp for i in xrange(len(outputs)): tests += 1 ftype = os.path.splitext(os.path.basename(outputs[i]))[1] if ftype in [".dcd", ".header", ".xtc"]: continue ignoreSign = False # Ignore signs on eignevectors if ftype == ".vec": ignoreSign = True logging.info("Testing: " + expects[i] + " " + outputs[i]) if comparator.compare(expects[i], outputs[i], epsilon, scaling_factor, ignoreSign): logging.info("Passed") testspassed += 1 else: logging.warning("Failed") testsfailed += 1 failedtests.append("Comparison of " + expects[i] + " and " + outputs[i]) return (tests, testspassed, testsfailed, failedtests)
def graph(): global xlim global show_peaks refresh() if show_peaks_entry.get() == "0": show_peaks = 0 if not dfs: load() if lmin_entry.get() and lmax_entry.get(): xlim = [int(lmin_entry.get()), int(lmax_entry.get())] meds = entry2.get().split(",") meds = [int(i) for i in meds] if title_entry.get(): compare(meds, dfs, nombres, title=title_entry.get(), xlim=xlim, peaks=int(show_peaks)) else: compare(meds, dfs, nombres, xlim=xlim, peaks=int(show_peaks))
def menu(): print(" ") a = input("Digite o primeiro número: ") if (comparator.validate(a)): print("") b = input("Digite o segundo número: ") if (comparator.validate(b)): comparator.compare(a, b) else: print("") print("Digite um número válido.") else: print(" ") print("Digite um número válido.")
def fileparser(filename, path1, path2, outputpath): try: parse1 = parse(path1 + '/' + filename) parse2 = parse(path2 + '/' + filename) merged = compare(parse1, parse2) outputxml = generatexml(merged) writeonfile(outputxml, outputpath, '/' + filename) except Exception as e: print(e)
def stresstest_with_comparator(): test_n = 1 while True: print(f"TEST #{test_n}") test_n += 1 gen_test(config, test_n) res = compare(config) if res == 1: print('FAIL') elif res == 2: print('Something went wrong.') else: print('SUCCES') if res != 0: print_test(config)
def __init__(self, hatch, queue): multiprocessing.Process.__init__(self, name="worker for filtered data") self.hatch = hatch self.queue = queue self.visual = visual.visual() self.util = util.util(self.hatch.get('debug')) self.analyze = analyze.analyze(self.hatch.get('debug')) self.compare = comparator.compare(self.hatch.get('debug'), self.util) self.running = True self.counter = 0 self.plot_counter = 0 self.reset_counter = 0 self.rawbuf = [ ] self.rawfft = [ ] self.raw = [ ] self.fft = [ ] self.word_tendency = None self.character = [ ] self.raw_character = [ ] self.uid = str(uuid.uuid4()) self.start()
def executeTests(userobjdir, rmafter=True, onlyobject=False, testexec=lambda dif: print(dif)): if not onlyobject: testobjdir = readHeader() testindex = "1" difs = [] while path.isfile(TESTS_FOLDER + "test" + testindex + ".txt"): testvals = readTest(testindex) if not path.isdir("renders"): mkdir("renders") imgorig = "renders/imgorig" + testindex + ".png" imguser = "******" + testindex + ".png" if not onlyobject: load(testobjdir, imgorig, *testvals) else: imguser = "******" + path.basename( userobjdir) + "_test" + testindex + ".png" load(userobjdir, imguser, *testvals) if not onlyobject: dif = compare(imgorig, imguser) difs.append(dif) testexec(dif) if rmafter: remove(imgorig) remove(imguser) testindex = str(int(testindex) + 1) return difs
def __init__(self, queue, debug, plot, dict, wave): multiprocessing.Process.__init__(self, name="worker for filtered data") self.queue = queue self.debug = debug self.plot = plot self.dict = dict self.wave = wave self.visual = visual.visual() self.util = util.util(debug) self.analyze = analyze.analyze(debug) self.compare = comparator.compare(debug, self.util) self.running = True self.counter = 0 self.plot_counter = 0 self.reset_counter = 0 self.rawbuf = [] self.rawfft = [] self.raw = [] self.fft = [] self.word_tendency = None self.character = [] self.raw_character = [] self.uid = str(uuid.uuid4()) self.start()
def test_a_lt_b(self): actual = compare(3, 7) self.assertEqual(-1, actual)
def run_test(protomol_path, conf_file, pwd, parallel): tests = 0 testspassed = 0 testsfailed = 0 failedtests = [] conf_param_overrides = parse_params(conf_file) epsilon = conf_param_overrides.get('epsilon', DEFAULT_EPSILON) scaling_factor = conf_param_overrides.get('scaling_factor', DEFAULT_SCALINGFACTOR) base = os.path.splitext(os.path.basename(conf_file))[0] if not parallel: logging.info('Executing Test: ' + base) else: logging.info('Executing Parallel Test: ' + base) cmd = [] if parallel: cmd.append('mpirun') cmd.append('-np') cmd.append('2') cmd.append(protomol_path) cmd.append(conf_file) p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (stdout, stderr) = p.communicate() if p.returncode > 0: s = 'Not able to execute Protomol!\n' s += 'cmd: ' + str(cmd) + '\n' logging.critical(s) expects = [] outputs = glob.glob('tests/output/' + base + '.*') outputtemp = [] for output in outputs: outbase = os.path.basename(output) if os.path.exists('tests/expected/' + outbase): outputtemp.append(output) expects.append('tests/expected/' + outbase) outputs = outputtemp for i in xrange(len(outputs)): tests += 1 ftype = os.path.splitext(os.path.basename(outputs[i]))[1] if ftype in ['.header', '.xtc']: continue ignoreSign = False # Ignore signs on eignevectors if ftype == '.vec': ignoreSign = True logging.info('\tTesting: ' + expects[i] + ' ' + outputs[i]) if ftype == ".dcd": if compare_dcd.compare_dcd(expects[i], outputs[i], epsilon, scaling_factor, ignoreSign): logging.info('\t\tPassed') testspassed += 1 else: logging.warning('\t\tFailed') testsfailed += 1 failedtests.append('Comparison of ' + expects[i] + ' and ' + outputs[i]) if args.errorfailure: sys.exit(1) else: if comparator.compare(expects[i], outputs[i], epsilon, scaling_factor, ignoreSign): logging.info('\t\tPassed') testspassed += 1 else: logging.warning('\t\tFailed') testsfailed += 1 failedtests.append('Comparison of ' + expects[i] + ' and ' + outputs[i]) if args.errorfailure: sys.exit(1) return (tests, testspassed, testsfailed, failedtests)
def classMaker(sequence, myRCList): print "\n" print "Reading frame 1: " Rframe1 = rFrameClass.Rframe(sequence, 0, 3) comparator.compare(Rframe1.format()) print "\n" print "Reading frame 2: " Rframe2 = rFrameClass.Rframe(sequence, 1, 4) comparator.compare(Rframe2.format()) print "\n" print "Reading frame 3: " Rframe3 = rFrameClass.Rframe(sequence, 2, 5) comparator.compare(Rframe3.format()) print "\n" print "Reading frame 4: " Rframe4 = rFrameClass.Rframe(myRCList, 0, 3) comparator.compare(Rframe4.format()) print "\n" print "Reading frame 5: " Rframe5 = rFrameClass.Rframe(myRCList, 1, 4) comparator.compare(Rframe5.format()) print "\n" print "Reading frame 6: " Rframe6 = rFrameClass.Rframe(myRCList, 2, 5) comparator.compare(Rframe6.format())
def test_exact_partial_match(self): """Tests that an array matches a different array that contains all of its elements in order.""" self.assertTrue(comparator.compare(self.arr1, self.arr2, MFCC_MATCH_THRESHOLD))
import input_parser import comparator import subprocess import util import sys monpoly = "" stream = "" stream_config = "" inp = sys.argv[1:] param = input_parser.get_param(inp) for tool, paths in param: if tool == 'monpoly': popen = subprocess.Popen(monpoly + " -s " + paths.get('signature') + " -f" + paths.get('formula') + " -l" + paths.get('log') + " > m_out", stdout=True, stderr=False) popen.communicate() param.get('monpoly').update({'out': 'm_out'}) elif tool == 'stream': s_param = paths.get('stream') util.stream_set_src(paths.get('script'), paths.get('logs')) dest = util.stream_get_dest(paths.get('script')) popen = subprocess.Popen(stream + " -c " + stream_config + s_param.get('script')) popen.communicate() param.get('stream').update({'out': dest}) comparator.compare(monpoly=param.get('monpoly').get('out'), stream=param.get('stream').get('out'))
expects = filter(untestable, expects) outputs = filter(untestable, outputs) # Compare Outputs output_size = len(outputs) output_pass = [] output_fail = [] for i in xrange(output_size): ignoreSign = False ftype = os.path.splitext(os.path.basename(outputs[i]))[1] if ftype == '.vec': ignoreSign = True if comparator.compare(expects[i], outputs[i], epsilon, scaling_factor, ignoreSign): string = outputs[i] + " matches" output_pass.append(string) print string else: string = outputs[i] + " differs" output_fail.append(string) print string print name + " " + str(output_size) + " " + str(len(output_pass)) # Create XML if len(output_pass) == output_size: stats_pass += 1 passed_tests.append({'id': testid, 'name': name}) else:
def test_not_a_match(self): """Tests that arrays containing different elements, where neither is a slice of the other, do not match if their elements are numerically far apart.""" self.assertFalse(comparator.compare(self.arr1, self.arr4, MFCC_MATCH_THRESHOLD))
def test_a_eq_b(self): actual = compare(7, 7) self.assertEqual(0, actual)
def test_a_gt_b(self): actual = compare(7, 3) self.assertEqual(1, actual)
def test_exact_match(self): """Tests that an array matches itself.""" self.assertTrue(comparator.compare(self.arr1, self.arr1, MFCC_MATCH_THRESHOLD))
if __name__ == "__main__": desc = "code_diff сравнивает попарно посслыки разных пользователей на похожесть и если пара" \ " подозрительна " \ "показывает в программе сравнения (по умолчанию ./kdiff3) " \ "в папке с поссылками за контест файлы должны назваться runid-userid-problem.{language suffix}" parser = argparse.ArgumentParser(description=desc, prog="code_diff") parser.add_argument('contest_folder', help='путь к папке с поссылками') parser.add_argument('-d', '--diff', default="./kdiff3", help='путь к программе сравнения файлов(kdiff3, vimdiff, ' 'diff и т.д.)') parser.add_argument('-l', '--log', default="./code_diff.log", help='путь к файлу, где сохраняются подозрительные программы') parser.add_argument('-m', '--mode', default='last', choices=['all', 'last'], help='режим работы; all - проверять все ' 'поссылки; last - проверять только ' 'последнюю поссылку пользователя по ' 'каждой задаче') parser.add_argument('-w', '--without-problem', dest='without', action="append", help='задача которую не нужно проверять, ' 'можно использовать несколько раз, если таких ' 'задач много') parser.add_argument('--version', action='version', version='%(prog)s 0.0') parser.add_argument('--max-common-len', '-mcl', type=float, dest='mcl', help='максимальное соотношение ' 'при котором файлы считаются не ' 'подозрительными') parser.add_argument('-q', '--quiet', action="store_true", help='если указан парметр, то все подозрительные просто ' 'будут сохранены в log, и не будет вызываться ' 'программа сравнения') args = parser.parse_args() log_file = open(args.log, "w") comparator.compare(args.contest_folder, args.diff, log_file, args.without, args.mcl, args.quiet, args.mode) log_file.close()
#!/usr/bin/python import comparator import sys import argparse import logging if __name__ == '__main__': parser = argparse.ArgumentParser(description='File comparison tool for floating point data' ) parser.add_argument('original', help='Original file to compare against') parser.add_argument('new', help='New file to comare against') parser.add_argument('epsilon', type=float, help='Epsilon to compare files with') parser.add_argument('--scale', type=float, default=float(1), help='Scaling factor for New file values') parser.add_argument('--ignore-sign', action='store_true', default=False, help='Ignore sign differences between files') parser.add_argument('--verbose', '-v', action='store_true', default=False, help='Verbose output') args = parser.parse_args() level = logging.INFO if args.verbose: level = logging.DEBUG logging.basicConfig(level=level) files_same = comparator.compare(args.original, args.new, args.epsilon, args.scale, ignoreSign=args.ignore_sign) if not files_same: logging.warn('Files Differ')
expects = filter(untestable, expects) outputs = filter(untestable, outputs) # Compare Outputs output_size = len(outputs) output_pass = [] output_fail = [] for i in xrange(output_size): ignoreSign = False ftype = os.path.splitext(os.path.basename(outputs[i]))[1] if ftype == ".vec": ignoreSign = True if comparator.compare(expects[i], outputs[i], epsilon, scaling_factor, ignoreSign): string = outputs[i] + " matches" output_pass.append(string) print string else: string = outputs[i] + " differs" output_fail.append(string) print string print name + " " + str(output_size) + " " + str(len(output_pass)) # Create XML if len(output_pass) == output_size: stats_pass += 1 xml_test = ET.SubElement(xml_pass, "Test") xml_test.set("id", str(testid))
def run(self): compare(self.contest_path, self.diff_program, self.log_file, self.without_problems, self.mcl, self.is_quiet, self.mode)
type=float, help='Epsilon to compare files with') parser.add_argument('--scale', type=float, default=float(1), help='Scaling factor for New file values') parser.add_argument('--ignore-sign', action='store_true', default=False, help='Ignore sign differences between files') parser.add_argument('--verbose', '-v', action='store_true', default=False, help='Verbose output') args = parser.parse_args() level = logging.INFO if args.verbose: level = logging.DEBUG files_same = comparator.compare(args.original, args.new, args.epsilon, args.scale, ignoreSign=arg.ignore_sign) if not files_same: logging.warn("Files Differ")