def main(): if len(sys.argv) != 6: print('Usage: '+sys.argv[0]+' URL databasehost databaseport datenbaseuser databasepassword') print('e.g. '+sys.argv[0]+ 'https://gerbera.informatik.uni-stuttgart.de:8081 gerbera.informatik.uni-stuttgart.de 3306 tourenplaner toureNPlaner') sys.exit(1) cmdline = ['mysql', '-u', sys.argv[4], '-p'+sys.argv[5] ,'--verbose', '--force', '--host', sys.argv[2], '--port', sys.argv[3]] #initialize DB PIPE = None initFileSql = io.open('initTestDB.sql', 'rt', encoding='UTF-8') Popen(cmdline,stdin = initFileSql, stdout=PIPE) #execute tests http = httplib2.Http(disable_ssl_certificate_validation=True) requester = tester.Requester(http) t = tester.Tester(sys.argv[1], requester, GetAllTests()) t.runTests() #finalize DB PIPE = None finalFileSql = io.open('finalTestDB.sql', 'rt', encoding='UTF-8') Popen(cmdline,stdin = finalFileSql, stdout=PIPE)
def run_tests(verbose=True): m = fsm.ControlFSM() t = tester.Tester(m, [ 'RegDst', 'RegWrite', 'ALUSrcA', 'MemRead', 'MemWrite', 'MemToReg', 'lorD', 'IRWrite', 'PCWrite', 'PCWriteCond', 'AluOP1', 'AluOP0', 'AluSrcB1', 'AluSrcB0', 'PCSrc1', 'PCSrc0' ]) out = [ "-0010-0110000100", # 0 "-0000--0000011--", # 1 "-0100--0000010--", # 2 "-0-10-1000------", # 3 "11-000-000------", # 4 "-0-01-1000------", # 5 "-0100--0001000--", # 6 "11-000-000------", # 7 "-0100--001010001", # 8 "-0-00--010----10" ] # 9 t.check_output(out[0]) t.run_test("100011", [out[1], out[2], out[3], out[4], out[0]]) t.run_test("101011", [out[1], out[2], out[5], out[0]]) t.run_test("000000", [out[1], out[6], out[7], out[0]]) t.run_test("000100", [out[1], out[8], out[0]]) t.run_test("000010", [out[1], out[9], out[0]]) return t.status()
def do_tests(client, output, server, nb): output.write('<td style="vertical-align:top" width="%d%%">\n' % int(100. / nb)) start = time.time() t = tester.Tester(client, output, server) m = '?BUG?' try: try: t.initialize() run('test_home', t) run('test_table', t) run('test_popup', t) except tester.Regtest: pass if t.errors: m = '***bad[' + ' '.join(t.errors) + ']***' else: m = 'ok' finally: if t: t.stop() m = t.client_name + ':' + m + '(%ds) ' % (time.time() - start) output.write(m + '</td>\n') return m
def test(self, ans, client): patch = os.path.join(self.__dir, "abc.ans") with open(patch, "wb") as f: f.write(ans) os.chmod(patch, 0o755) client.write("[*] SLA Test Start...") if not tester.Tester(patch, USER, alarm=7).run_tests( gen_SLA_test(self.__opt)): client.write("[!] SLA Test Failed!") return False client.write("[*] SLA Test Done") client.write("[*] Vulnerability Test Start...") if not tester.Tester(patch, USER, alarm=7).run_tests( gen_PATCH_test(self.__opt)[:self.__stage]): client.write("[!] Vulnerability Test Failed!") return False client.write("[*] Vulnerability Test Done") return True
def main() -> int: argparser = argparse.ArgumentParser( description='Zubax Embedded Bootloader automated test script') argparser.add_argument( 'iface', help='name of the CAN interface, e.g. "can0", "/dev/ttyACM0"') argparser.add_argument( 'uid', help='unique ID of the device under test as a hex string, e.g. ' '37ffdc05465430353344164300000000, or as a base64 encoded string, e.g. ' '"N//cBUZUMDUzRBZDAAAAAA==". The string may contain spaces, they will be removed.' ) argparser.add_argument( 'valid_fw_dir', help='path to the directory with valid firmware images') argparser.add_argument( 'invalid_fw_dir', help='path to the directory with invalid firmware images') argparser.add_argument('--verbose', '-v', action='count', help='verbosity level (-v, -vv)') argparser.add_argument( '--nid', help='local node ID used by the script (default: 127)', type=int, default=127) args = argparser.parse_args() _configure_stderr_logging(args.verbose) iface = args.iface try: args.uid = args.uid.replace(' ', '') if len(args.uid) == 32: uid = binascii.unhexlify(args.uid) else: uid = binascii.a2b_base64(args.uid) except Exception as ex: logger.error('Could not parse UID: %r', ex, exc_info=True) return 1 logger.info('Started; iface %s, UID %s', iface, binascii.hexlify(uid).decode('utf8')) try: t = tester.Tester(iface, uid, os.getcwd(), args.valid_fw_dir, args.invalid_fw_dir, args.nid) t.run() except Exception as ex: logger.error('Test failure: %r', ex, exc_info=True) return 1 else: return 0
def main(args): ''' Entry point of the microgames program ''' pygame.init() try: surface = pygame.display.set_mode([locals.WIDTH, locals.HEIGHT]) pygame.display.set_caption('Microgames Tester') clock = pygame.time.Clock() t = tester.Tester(surface) while not t.finished: events = pygame.event.get() clock.tick(locals.FPS) t.update(events) t.render() pygame.display.flip() except Exception as e: ty, v, tb = sys.exc_info() print 'An exception occurred. Terminating the game!' print traceback.print_exception(ty, v, tb) pygame.quit() sys.exit()
def __init__(self, window, test=False): QThread.__init__(self) self.window = window if not test: import dataStream as stream self.window.statusBar().showMessage( "Opening connection to remote...", 2000) print("Opening connection to remote...") self.s = stream.DataStream() else: import tester as t self.window.statusBar().showMessage( "Opening tester data stream...", 2000) print("Opening tester data stream...") self.s = t.Tester() self.data_recorder = data.Data() return
def main(): parser = argparse.ArgumentParser("Tic Tac Toe game") parser.add_argument('-t', '--tester', type=int, metavar="[Num of tests]", help="Random tester against Hard computer") args = parser.parse_args() gameObj = game.Game() if args.tester: testerObj = tester.Tester(gameObj) testerObj.testerRunner(args.tester) exit(0) numberOfPlayers = readInt("How many players: ") if numberOfPlayers == 2: gameObj.multiPlayerGame() elif numberOfPlayers == 1: computerLevel = readInt( "Level(1:Hard, 2:Medium, 3:Easy, Default:Easy:") gameObj.singlePlayerGame(computerLevel)
def test_execution(runs): """Test the testsuite to ensure it can run successfully at least once. The testsuite will run through the tester.py test process to ensure that the testsuite can actually run successfully. Args: runs (int): the number of runs the testsuite will be tested for """ testRunner = tester.Tester() try: testRunner.begin_testing(True, False, runs=runs) #logger.info("Testing Runs Results...") #logger.info("Successes: {}".format(testRunner.successes)) #logger.info("Timeouts: {}".format(testRunner.timeouts)) #logger.info("Dataraces: {}".format(testRunner.dataraces)) #logger.info("Deadlock: {}".format(testRunner.deadlocks)) #logger.info("Errors: {}".format(testRunner.errors)) if (testRunner.errors >= 1): raise Exception('ERROR', 'testsuite') elif (testRunner.timeouts >= 1): raise Exception('ERROR', 'config._CONTEST_TIMEOUT_SEC is too low') elif (testRunner.dataraces >= 1): logger.info("Data races were encountered") elif (testRunner.deadlocks >= 1): logger.info("Deadlocks were encountered") elif (testRunner.successes >= 1): logger.info("Test suite execution successful") else: logger.warn("The test suite wasn't executed successfully") except Exception as message: print(message.args) sys.exit()
def run_contest(): """Run the testsuite with ConTest using the approach in tester.py.""" testRunner = tester.Tester() testRunner.begin_testing(True, False)
def test_tester(monkeypatch, myMock): dataset = [{ 'label': 0, 'sentence_splits': [['a', 'b', 'c'], ['c', 'd']], 'candidate_ids': torch.tensor([0, 1]), 'embedded_page_content': torch.tensor([[1], [-2], [2], [3], [-3], [4]]), 'entity_page_mentions': torch.tensor([[1], [-2], [0], [3], [0], [4]]), 'p_prior': torch.tensor([0.1, 0.9]) }, { 'label': 2, 'sentence_splits': [['a', 'b', 'c'], ['c', 'd']], 'candidate_ids': torch.tensor([2, 1]), 'embedded_page_content': torch.tensor([[1], [-2], [2], [3], [-3], [4]]), 'entity_page_mentions': torch.tensor([[1], [-2], [0], [3], [0], [4]]), 'p_prior': torch.tensor([0.1, 0.9]) }, { 'label': 1, 'sentence_splits': [['a', 'b', 'c'], ['c', 'd']], 'candidate_ids': torch.tensor([3, 1]), 'embedded_page_content': torch.tensor([[1], [-2], [2], [3], [-3], [4]]), 'entity_page_mentions': torch.tensor([[1], [-2], [0], [3], [0], [4]]), 'p_prior': torch.tensor([0.1, 0.9]) }] num_entities = 10 embed_len = 200 batch_size = 3 entity_embeds = nn.Embedding(num_entities, embed_len, _weight=torch.randn( (num_entities, embed_len))) embedding_dict = dict( zip(string.ascii_lowercase, [ torch.tensor([i]) for i, char in enumerate(string.ascii_lowercase) ])) token_idx_lookup = dict( zip(embedding_dict.keys(), range(len(embedding_dict)))) embedding = nn.Embedding.from_pretrained( torch.stack([embedding_dict[token] for token in token_idx_lookup])) vector_to_return = entity_embeds(torch.tensor([1, 1, 1])) model = get_mock_model(vector_to_return) device = None batch_sampler = BatchSampler(RandomSampler(dataset), batch_size, True) mock_experiment = create_autospec(Experiment, instance=True) calc_logits = Logits() softmax = Softmax() logits_and_softmax = { 'mention': lambda hidden, candidate_ids_or_targets: softmax( calc_logits(hidden, entity_embeds(candidate_ids_or_targets))) } with monkeypatch.context() as m: m.setattr(nn, 'DataParallel', _.identity) m.setattr(u, 'tensors_to_device', lambda batch, device: batch) tester = t.Tester( dataset=dataset, batch_sampler=batch_sampler, model=model, logits_and_softmax=logits_and_softmax, embedding=embedding, token_idx_lookup=token_idx_lookup, device=device, experiment=mock_experiment, ablation=['prior', 'local_context', 'document_context'], use_adaptive_softmax=False) assert tester.test() == (1, 3) labels_for_batch = tester._get_labels_for_batch( torch.tensor([elem['label'] for elem in dataset]), torch.tensor([[1, 0], [4, 5], [1, 0]])) assert torch.equal(labels_for_batch, torch.tensor([1, -1, 0]))
if len(row[i])>0: tags += [row[i]] featureset += util.featuresetIt( util.featureIt(util.tokenizeIt(title)), tags ) + util.featuresetIt( util.featureIt(util.tokenizeIt(body)), tags ) lines+=1 if MAX_LOADED_LINES>0 and lines>MAX_LOADED_LINES: print "Maximum exceeded!" break print "%d lines parsed." % lines #break self.saveFeaturesetFile(featureset,filename+".featureset") return featureset def getFeatureset(self,filename): if os.path.exists(filename+".featureset"): return self.loadFeaturesetFile(filename+".featureset") else: return self.newFeatureset(filename) if __name__=="__main__": classifier = stackClassifier() classifier.train("/media/Arquivos/g4/NLP & ML/stackoverflow/train.csv") # #TESTER print "\nTESTER..." f = open("/media/Arquivos/g4/NLP & ML/stackoverflow/train.csv","rb") reader = csv.reader(f) reader.next() test = tester.Tester(classifier.getNaiveObj(),reader)#,classifier.getCsvObj()) test.test(True,1)
def test_eval_seg(net, model, test_root, origin_root, gt_root, test_list, out_root, uniform_size, mean, batch_size, show=0, save_seg=0, save_img=0, save_prob=0, use_hyper=0, hyper_downsample_rate=1, hyper_centroids_name=None, score_name='score', start=0, end=-1, gpu=-1, f=None): # init OUT_PROB = False LUT = load_color_LUT_21( os.path.dirname(__file__) + '/VOC_color_LUT_21.mat') if save_seg: if not os.path.isdir(out_root + '/seg/'): os.makedirs(out_root + '/seg/') if not os.path.isdir(out_root + '/vlz/'): os.makedirs(out_root + '/vlz/') if save_prob: if not os.path.isdir(out_root + '/prob/'): os.makedirs(out_root + "/prob/") if not os.path.isdir(out_root + '/shape/'): os.makedirs(out_root + "/shape/") OUT_PROB = True if save_img: if not os.path.isdir(out_root + '/img/'): os.makedirs(out_root + "/img/") OUT_PROB = True with open(test_list, 'r') as infile: img_list = [ line.strip() for line in infile.readlines() if len(line.strip()) > 0 ] if end == -1: img_list = img_list[start:] elif end <= len(img_list): img_list = img_list[start:end] else: raise Exception('end should not be larger than img_list length') base_size = [uniform_size, uniform_size] mean_map = np.tile(mean, [base_size[0], base_size[1], 1]) # H x W x C # centroids init for hyper-column if use_hyper: hyper_dsr = hyper_downsample_rate hyper_total = (uniform_size / hyper_dsr) * (uniform_size / hyper_dsr) hyper_yc = np.tile( np.arange(0, uniform_size, hyper_dsr).reshape( (uniform_size / hyper_dsr, 1)), [1, uniform_size / hyper_dsr]).reshape((hyper_total, 1)) hyper_xc = np.tile( np.arange(0, uniform_size, hyper_dsr).reshape( (1, uniform_size / hyper_dsr)), [uniform_size / hyper_dsr, 1]).reshape((hyper_total, 1)) hyper_centroids_blob = np.tile(np.hstack((hyper_yc, hyper_xc)), [batch_size, 1, 1]) # caffe model init caffe_tester = tester.Tester(net, model, gpu) if use_hyper: if hyper_centroids_name in caffe_tester.blobs.keys(): caffe_tester.blobs[ hyper_centroids_name].data.flat = hyper_centroids_blob.flat else: raise Exception("Can not find the blob: %s" % hyper_centroids_name) # loop list hist = np.zeros((21, 21)) for i in range(0, len(img_list), batch_size): if i % 100 == 0: print('Processing: %d/%d' % (i, len(img_list))) true_batch_size = min(batch_size, len(img_list) - i) batch_data = np.zeros((batch_size, 3, base_size[0], base_size[1]), dtype=np.float) for k in range(true_batch_size): if not os.path.isfile(test_root + img_list[i + k]): raise Exception('file not exist: %s' % (test_root + img_list[i + k])) sys.exit(1) img = cv2.imread(test_root + img_list[i + k]) # BGR, 0-255 batch_data[k, ...] = (resize_uniform.resize_pad_to_fit( img, base_size, pad_value=mean) - mean_map).transpose( (2, 0, 1)) inputs = {} inputs['data'] = batch_data qblobs = caffe_tester.predict(inputs, {}, [score_name]) if use_hyper: if len(qblobs[score_name].shape) != 2: raise Exception("qblobs[score_name] should have 2 axis") for k in range(0, true_batch_size): origin_img = cv2.imread(origin_root + img_list[i + k]) origin_shape = origin_img.shape if gt_root is not None: gt_img = cv2.imread(gt_root + img_list[i + k].split('.')[0] + '.png')[:, :, 0] if use_hyper: if OUT_PROB: prob_map = qblobs[score_name].reshape( (batch_size, uniform_size / hyper_dsr, uniform_size / hyper_dsr, -1))[k, ...].transpose( (2, 0, 1)) cls_map = qblobs[score_name].argmax(axis=1).reshape( (batch_size, uniform_size / hyper_dsr, uniform_size / hyper_dsr))[k, ...].astype(np.uint8) else: if OUT_PROB: prob_map = qblobs[score_name][k] cls_map = np.array(qblobs[score_name][k].transpose( 1, 2, 0).argmax(axis=2), dtype=np.uint8) if save_prob: np.save( out_root + "/prob/" + img_list[i + k].split('.')[0] + ".npy", prob_map) np.save( out_root + "/shape/" + img_list[i + k].split('.')[0] + ".npy", origin_shape[:2]) if save_img: cv2.imwrite(out_root + '/img/' + img_list[i + k], origin_img) # origin size out_map = np.uint8(LUT[cls_map] * 255) cls_map_origin = resize_uniform.resize_crop_to_fit( cls_map, origin_shape[:2], interp=cv2.INTER_NEAREST) out_map_origin = resize_uniform.resize_crop_to_fit( out_map, origin_shape[:2], interp=cv2.INTER_NEAREST) # mIU if gt_root is not None: hist += fast_hist(gt_img.flatten(), cls_map_origin.flatten(), 21) if show: cv2.imshow("image", origin_img) cv2.imshow("seg result", out_map_origin) cv2.waitKey(0) if save_seg: cls_map_fn = out_root + '/seg/' + img_list[i + k].split( '.')[0] + ".png" out_map_fn = out_root + "/vlz/" + img_list[i + k].split( '.')[0] + ".png" if not os.path.isdir(os.path.dirname(cls_map_fn)): os.makedirs(os.path.dirname(cls_map_fn)) if not os.path.isdir(os.path.dirname(out_map_fn)): os.makedirs(os.path.dirname(out_map_fn)) cv2.imwrite(cls_map_fn, cls_map_origin) cv2.imwrite(out_map_fn, out_map_origin) # results if gt_root is not None: acc = np.diag(hist).sum() / hist.sum() print '>>>', 'overall accuracy', acc acc = np.diag(hist) / hist.sum(1) print '>>>', 'mean accuracy', np.nanmean(acc) iu = np.diag(hist) / (hist.sum(1) + hist.sum(0) - np.diag(hist)) print '>>>', 'per class IU:\n', iu show_iu = ["{:.2f}".format(i * 100) for i in iu] print '>>>', show_iu print '>>>', 'mean IU', np.nanmean(iu) if f is not None: f.write('model: %s\n' % model) f.write('%s\n' % show_iu) f.write('Mean IU: %f\n\n' % np.nanmean(iu))
def __init__(self, parent=None, args=None, macros=None): super(ComMpmTests, self).__init__(parent=parent, macros=macros) logging.basicConfig(filename='comMpmTests%s.log', level=logging.DEBUG) plutoGateway_mapping_path = path.join( path.dirname(path.realpath(__file__)), "mapping", "com_mpm_modbus_mapping.csv") testbox_mapping_path = path.join(path.dirname(path.realpath(__file__)), "mapping", "PLC_Certification_Chassis.xlsx") testBox, plutoGateway = import_mappings(plutoGateway_mapping_path, testbox_mapping_path, 'COM MPM Cables') print('ola') self.mpm_tester = tester.Tester(testBox, plutoGateway) #self.mpm_tester.connectTestBox() #self.mpm_tester.connectGateway(timeout=30) self.mpm_tester.tests.append( com_mpm_tests.TestPlutoGatewayConfig(self.mpm_tester, -1)) self.mpm_tester.tests.append( com_mpm_tests.TestPlutoPLCsPresent(self.mpm_tester, -1)) self.mpm_tester.tests.append( com_mpm_tests.TestChannelsBootDefault(self.mpm_tester, -1)) self.mpm_tester.tests.append( com_mpm_tests.TestPlutoWriteReadback(self.mpm_tester, -1)) self.mpm_tester.tests.append( com_mpm_tests.TestPermitsBlock(self.mpm_tester, -1)) self.mpm_tester.tests.append( com_mpm_tests.TestAcPermitCoolantValve(self.mpm_tester, -1)) self.mpm_tester.tests.append( com_mpm_tests.TestVacuumToRefPermits(self.mpm_tester, -1)) #self.mpm_tester.tests.append(com_mpm_tests.TestColdCryoPermits(self.mpm_tester, -1)) for i, test in enumerate(self.mpm_tester.tests): test.id = i self.table = self.ui.tableWidget headers = ["Test", "Description", "", "Step", "Details"] self.table.setRowCount(len(self.mpm_tester.tests)) self.table.setColumnCount(len(headers)) self.table.setHorizontalHeaderLabels(headers) self.table.setVerticalHeaderLabels( [str(e) for e in list(range(1, len(self.mpm_tester.tests) + 1))]) for i, test in enumerate(self.mpm_tester.tests): self.update_table_line(i) self.table.setCurrentCell(0, 0, QItemSelectionModel.Rows) self.table.itemChanged.connect(self.item_changed) self.table.setColumnWidth(0, 160) self.table.setColumnWidth(1, 300) self.table.setColumnWidth(2, 50) self.table.setColumnWidth(3, 250) self.mpm_tester.test_line_update.connect(self.update_table_line) self.mpm_tester.monitor_update.connect(self.update_monitor_menu) self.ui.runAllButton.clicked.connect(self.mpm_tester.run_all) self.ui.abortButton.clicked.connect(self.mpm_tester.abort)
import websockets import tester async def connect(base: str) -> None: await websockets.connect(base) if __name__ == '__main__': Tester = tester.Tester() Tester.addAsyncTest('connect', connect('ws://localhost:2000')) # type: ignore
def start_app(): tester.Tester()
import stringproblems import stringproblems2 import stringproblems2test import stringproblems3 import stringproblems4 import stringproblems3test import stringproblems4test import stringanswers import stringanswers2 import stringanswers3 import stringanswers4 import listproblems import listanswers import listproblemstest import sortingproblems import sortingproblemstest import sortinganswers import yahtzeeanswers import yahtzeeproblems import yahtzeetest import tester moduleToTest = yahtzeeanswers testModule = yahtzeetest myTester = tester.Tester(moduleToTest, getattr(testModule, "cases")) myTester.testMethod("sum_of_dice") myTester.testMethod("three_of_a_kind") myTester.testMethod("full_house")
def __init__(self, parent=None, args=None, macros=None): super(ColdTests, self).__init__(parent=parent, macros=macros) logging.basicConfig(filename='vaccumTests%s.log', level=logging.DEBUG) plutoGateway_mapping_path = path.join( path.dirname(path.realpath(__file__)), "mapping", "cold_modbus_mapping.csv") testbox_mapping_path = path.join(path.dirname(path.realpath(__file__)), "mapping", "PLC_Certification_Chassis.xlsx") testBox, plutoGateway = import_mappings(plutoGateway_mapping_path, testbox_mapping_path, 'ColdCryo Cables') self.cold_tester = tester.Tester(testBox, plutoGateway) self.cold_tester.connectTestBox() self.cold_tester.connectGateway(timeout=30) self.cold_tester.tests.append( cold_tests.TestPlutoGatewayConfig(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestPlutoPLCsPresent(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestChannelsBootDefault(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestPlutoWriteReadback(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestDigitalInputs(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestSensorsValid(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestImmediateTrips(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestImmediatePowerTrips(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestOilFailureWhileRunning(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestCurrentValid(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestDelayPowerTrip(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestDelayDisPressTrip(self.cold_tester, -1)) self.cold_tester.tests.append( cold_tests.TestDelayDisTempTrip(self.cold_tester, -1)) for i, test in enumerate(self.cold_tester.tests): test.id = i self.table = self.ui.tableWidget headers = ["Test", "Description", "", "Step", "Details"] self.table.setRowCount(len(self.cold_tester.tests)) self.table.setColumnCount(len(headers)) self.table.setHorizontalHeaderLabels(headers) self.table.setVerticalHeaderLabels( [str(e) for e in list(range(1, len(self.cold_tester.tests) + 1))]) for i, test in enumerate(self.cold_tester.tests): self.update_table_line(i) self.table.setCurrentCell(0, 0, QItemSelectionModel.Rows) self.table.itemChanged.connect(self.item_changed) self.table.setColumnWidth(0, 160) self.table.setColumnWidth(1, 300) self.table.setColumnWidth(2, 50) self.table.setColumnWidth(3, 250) self.cold_tester.test_line_update.connect(self.update_table_line) self.cold_tester.monitor_update.connect(self.update_monitor_menu) self.ui.runAllButton.clicked.connect(self.cold_tester.run_all) self.ui.abortButton.clicked.connect(self.cold_tester.abort)
import mpm_tests import cold_tests from mapping_parser import import_mappings import logging import time plutoGateway_mapping_path = path.join(path.dirname(path.realpath(__file__)), "mapping", "cold_modbus_mapping.csv") testbox_mapping_path = path.join(path.dirname(path.realpath(__file__)), "mapping", "PLC_Certification_Chassis.xlsx") testBox, plutoGateway = import_mappings(plutoGateway_mapping_path, testbox_mapping_path, 'ColdCryo Cables') mpm_tester = tester.Tester(testBox, plutoGateway) mpm_tester.connectTestBox() mpm_tester.connectGateway(timeout=30) #asdas #a= mpm_tests.TestPlutoConnect(mpm_tester, -1) #a.run() #a= mpm_tests.TestTestBoxConnect(mpm_tester, -1) #a.run() a = cold_tests.TestDigitalInputs(mpm_tester, 1) a.button_run() ''' while 1: start=time.time()
def start_app(): test_up = tester.Tester() test_up.fill_test_data()
def test(self, audio_to_test, speaker_id_worker, outq): print 'in test' tester = te.Tester(audio_to_test, speaker_id_worker, outq, self.gmm_models) tester.run()
def __init__(self, parent=None, args=None, macros=None): super(VaccumTests, self).__init__(parent=parent, macros=macros) #logging.basicConfig(filename=path.join(path.dirname(path.realpath(__file__)), "logs",'vaccumTests.log'), level=logging.DEBUG) logging.basicConfig(filename='C:\\Users\\joaoprod\\Documents\\GitHub\\lsstPLCsTestBox\\logs\\vaccumTests2.log', level=logging.DEBUG) logging.debug('This message should go to the log file') logging.info('So should this') logging.warning('And this, too') print(path.join(path.dirname(path.realpath(__file__)), "logs",'vaccumTests.log')) plutoGateway_mapping_path = path.join(path.dirname(path.realpath(__file__)), "mapping", "vac_modbus_mapping.csv") testbox_mapping_path = path.join(path.dirname(path.realpath(__file__)), "mapping", "PLC_Certification_Chassis.xlsx") testbox , plutoGateway = import_mappings(plutoGateway_mapping_path,testbox_mapping_path,'Vaccum cables') self.vac_tester = tester.Tester(testbox , plutoGateway) self.vac_tester.tests.append(vac_tests.TestPlutoGatewayConfig(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestPlutoPLCsPresent(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestChannelsBootDefault(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestPlutoWriteReadback(self.vac_tester, -1)) #self.vac_tester.tests.append(vac_tests.TestAnalogScaling(self.vac_tester, -1)) #self.vac_tester.tests.append(vac_tests.TestHvCvDifferences(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestCvValves(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestValveMonitors(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestHvStat(self.vac_tester, -1)) #self.vac_tester.tests.append(vac_tests.TestHvTurboOnOfflogic(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestHvTurboPermitBlock(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestHvTurboPermitAuto(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestCvStat(self.vac_tester, -1)) #self.vac_tester.tests.append(vac_tests.TestCvTurboOnOfflogic(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestCvTurboPermitBlock(self.vac_tester, -1)) self.vac_tester.tests.append(vac_tests.TestCvTurboPermitAuto(self.vac_tester, -1)) for i, test in enumerate( self.vac_tester.tests): test.id=i self.table = self.ui.tableWidget headers= ["Test","Description","","Step","Details"] self.table.setRowCount(len(self.vac_tester.tests)) self.table.setColumnCount(len(headers)) self.table.setHorizontalHeaderLabels(headers) self.table.setVerticalHeaderLabels([str(e) for e in list(range(1,len(self.vac_tester.tests)+1))]) for i, test in enumerate(self.vac_tester.tests): self.update_table_line(i) self.table.setCurrentCell(0, 0 ,QItemSelectionModel.Rows) self.table.itemChanged.connect(self.item_changed) self.table.setColumnWidth(0, 160) self.table.setColumnWidth(1, 300) self.table.setColumnWidth(2, 50) self.table.setColumnWidth(3, 250) self.vac_tester.test_line_update.connect(self.update_table_line) self.vac_tester.monitor_update.connect(self.update_monitor_menu) self.ui.runAllButton.clicked.connect(self.vac_tester.run_all) self.ui.abortButton.clicked.connect(self.vac_tester.abort)
def test_eval_seg(net, model, img_list, name_list, gt_list, out_root, nclass, crop_size, target_size, stride_ratio, mean, batch_size, show=0, save_seg=0, save_img=0, save_prob=0, save_saliency=0, use_hyper=0, hyper_downsample_rate=1, hyper_centroids_name=None, score_name='score', start=0, end=-1, gpu=-1, LUT=None, f=None): # preparing data if save_seg: if not os.path.isdir(out_root + '/seg/'): os.makedirs(out_root + '/seg/') if not os.path.isdir(out_root + '/vlz/'): os.makedirs(out_root + '/vlz/') if save_prob: raise NotImplementedError("save prob not implemented") if end == -1: img_list = img_list[start:] elif end <= len(img_list): img_list = img_list[start:end] else: raise Exception('end should not be larger than img_list length') base_size = [crop_size, crop_size] # grid hist = np.zeros((nclass, nclass)) img0 = cv2.imread(img_list[0]) stride = int(np.ceil(crop_size * stride_ratio)) hgrid_num = int(np.ceil((img0.shape[0] - crop_size) / float(stride))) + 1 assert (hgrid_num - 1) * stride + crop_size - img0.shape[0] < crop_size * 0.05 wgrid_num = int(np.ceil((img0.shape[1] - crop_size) / float(stride))) + 1 assert (wgrid_num - 1) * stride + crop_size - img0.shape[1] < crop_size * 0.05 mean_map = np.tile(mean, [base_size[0], base_size[1], 1]) # H x W x C # caffe model init caffe_tester = tester.Tester(net, model, gpu) if use_hyper: if hyper_centroids_name in caffe_tester.blobs.keys(): hyper_dsr = hyper_downsample_rate hyper_total = (crop_size / hyper_dsr) * (crop_size / hyper_dsr) hyper_yc = np.tile( np.arange(0, crop_size, hyper_dsr).reshape( (crop_size / hyper_dsr, 1)), [1, crop_size / hyper_dsr]).reshape((hyper_total, 1)) hyper_xc = np.tile( np.arange(0, crop_size, hyper_dsr).reshape( (1, crop_size / hyper_dsr)), [crop_size / hyper_dsr, 1]).reshape((hyper_total, 1)) hyper_centroids_blob = np.tile(np.hstack((hyper_yc, hyper_xc)), [batch_size, 1, 1]) caffe_tester.blobs[ hyper_centroids_name].data.flat = hyper_centroids_blob.flat else: raise Exception("Can not find the blob: %s" % hyper_centroids_name) # loop list for i in range(0, len(img_list)): if i % 10 == 0: print('Processing: %d/%d' % (i, len(img_list))) if not os.path.isfile(img_list[i]): raise Exception('file not exist: %s' % (img_list[i])) sys.exit(1) img = cv2.imread(img_list[i]) # BGR, 0-255 H, W = img.shape[:2] hstart = stride * np.arange(hgrid_num) wstart = stride * np.arange(wgrid_num) batch_data = np.array([ (crop_images.crop_padding(img, (wst, hst, crop_size, crop_size), mean) - mean_map).astype(np.float32).transpose(2, 0, 1) for hst in hstart for wst in wstart ]) assert batch_data.shape[0] >= batch_size assert batch_data.shape[0] % batch_size == 0 # if gt_list is not None: gt_img = cv2.imread(gt_list[i])[:, :, 0] ensemble_prob = np.zeros((nclass, H, W), dtype=np.float32) ensemble_cls = np.zeros((H, W), dtype=np.uint8) # loop crops by batch for j in range(batch_data.shape[0] / batch_size): inputs = { 'data': batch_data[j * batch_size:(j + 1) * batch_size, ...] } qblobs = caffe_tester.predict(inputs, {}, [score_name]) if use_hyper and len(qblobs[score_name].shape) != 2: raise Exception( "for hypercolumn, qblobs[score_name] should have 2 axis") for k in range(0, batch_size): if use_hyper: prob_map = qblobs[score_name].reshape( (batch_size, crop_size / hyper_dsr, crop_size / hyper_dsr, -1))[k, ...].transpose( (2, 0, 1))[:nclass, ...] else: prob_map = qblobs[score_name][k, nclass, ...] if prob_map.max() > 1 or prob_map.min() < 0: raise Exception("should with softmax") prob_map = np.array([ cv2.resize(pm, (crop_size, crop_size)) for pm in prob_map ]) hid, wid = (j * batch_size + k) // wgrid_num, (j * batch_size + k) % wgrid_num ensemble_prob[:, hid * stride:hid * stride + crop_size, wid * stride:wid * stride + crop_size] += prob_map # accumulate probability ensemble_cls = ensemble_prob.argmax(axis=0) if target_size is not None: ensemble_cls = cv2.resize(ensemble_cls, (target_size[1], target_size[0]), interpolation=cv2.INTER_NEAREST) ensemble_vlz = np.uint8(LUT[ensemble_cls]) # mIU if gt_list is not None: ensemble_cls[ensemble_cls >= nclass] = 0 hist += fast_hist(gt_img.flatten(), ensemble_cls.flatten(), nclass) if show: cv2.imshow("image", img) cv2.imshow("seg result", ensemble_vlz) cv2.waitKey(0) if save_seg: cls_map_fn = out_root + '/seg/' + name_list[i] + ".png" out_map_fn = out_root + "/vlz/" + name_list[i] + ".png" if not os.path.isdir(os.path.dirname(cls_map_fn)): os.makedirs(os.path.dirname(cls_map_fn)) if not os.path.isdir(os.path.dirname(out_map_fn)): os.makedirs(os.path.dirname(out_map_fn)) cv2.imwrite(cls_map_fn, ensemble_cls) cv2.imwrite(out_map_fn, ensemble_vlz) if gt_list is not None: acc = np.diag(hist).sum() / hist.sum() print '>>>', 'overall accuracy', acc acc = np.diag(hist) / hist.sum(1) print '>>>', 'mean accuracy', np.nanmean(acc) iu = np.diag(hist) / (hist.sum(1) + hist.sum(0) - np.diag(hist)) print '>>>', 'per class IU:\n', iu show_iu = ["{:.2f}".format(i * 100) for i in iu] print '>>>', show_iu print '>>>', 'mean IU', np.nanmean(iu) if f is not None: f.write('model: %s\n' % model) f.write('%s\n' % show_iu) f.write('Mean IU: %f\n\n' % np.nanmean(iu))