def client(): logging.log(logging.INFO, TestConfig().SQLALCHEMY_DATABASE_URI) app = create_app(TestConfig()) client = app.test_client() yield client
def validate(model): validate_config = TestConfig() validate_config.isTest = True logger = validate_config.test_logger logger.info("--------------------------------------------------------") logger.debug("test the model using the validate dataset") validate_dataset = create_dataset(validate_config) model.eval() model.clear_precision() model.set_validate_size(len(validate_dataset)) logger.info("validate dataset len: %d " % len(validate_dataset)) validate_total_iter = int( len(validate_dataset) / validate_config.batch_size) for j, valida_data in enumerate(validate_dataset): model.set_input(valida_data) logger.debug("[%s/%s]" % (j, validate_total_iter)) model.test() # output the precision logger.debug(model.get_model_precision()) logger.debug(model.get_model_class_balance_precision()) logger.info("mean accuracy: {}".format( torch.mean(model.get_model_precision()))) logger.info("class_balance accuracy: {}".format( torch.mean(model.get_model_class_balance_precision()))) logger.debug("validate mode end") logger.info("--------------------------------------------------------")
def setUp(self): #Config config = TestConfig() #NoSuchKey Error error = { 'Error': { 'Code': 'NoSuchKey', 'Message': 'The specified key does not exist.', 'Key': 'd20b1c38-2f5f-4b48-b604-eb90f82ff800' }, 'ResponseMetadata': { 'HTTPStatusCode': 404, 'RetryAttempts': 0 } } #Mock mock = MagicMock() mock.get_object(Bucket=config.BUCKET_NAME, Key='d20b1c38-2f5f-4b48-b604-eb90f82ff800') mock.get_object.side_effect = ClientError(error, 'GetObject') config.S3 = mock #Storage self.storage = AWSStorage(config) self.config = config
class FooTest(unittest.TestCase): def setUp(self): self.config = Config() self.app = create_app(self.config) self.test_client = self.app.test_client() with self.app.app_context(): db.create_all() def tearDown(self): self.config.drop_db() def log(self, msg): if SHOW_LOG_MESSAGES: print msg def test_empty_root(self): rv = self.test_client.get('/') assert 'Hello' in rv.data def test_add_foo(self): testUrl = '/foo/' with self.app.app_context(): #create_permissions_universe(db) raw = { 'title' : 'hellofoo' } d = json.dumps(raw) rv = self.test_client.post(testUrl, data=d, content_type='application/json') response = json.loads(rv.data) assert response['success'] == True
def test_resolve(): test_config = TestConfig('http://www.{{a}}', 'test', body={"key1": "{{b}}", "key2": ["{{c}}", {"key3": "{{d.e}}"}]}) args = {"a": "variable_a", "b": "variable_b", "c": "variable_c", "d": {"e": "variable_e"}} test_config.resolve(args) result = to_json(test_config) print(result)
class FooTest(unittest.TestCase): def setUp(self): self.config = Config() self.app = create_app(self.config) self.test_client = self.app.test_client() with self.app.app_context(): db.create_all() def tearDown(self): self.config.drop_db() def log(self, msg): if SHOW_LOG_MESSAGES: print msg def test_empty_root(self): rv = self.test_client.get('/') assert 'Hello' in rv.data def test_add_foo(self): testUrl = '/foo/' with self.app.app_context(): #create_permissions_universe(db) raw = {'title': 'hellofoo'} d = json.dumps(raw) rv = self.test_client.post(testUrl, data=d, content_type='application/json') response = json.loads(rv.data) assert response['success'] == True
def test_method(gpu): os.environ["CUDA_VISIBLE_DEVICES"] = gpu config = TestConfig() # config.checkpoints_dir = "/media/data2/xyz_data/CelebA_full/full_third_2019-6-19_0.9135_ckp" print("{} model was initialized".format(config.model_name)) # dataset is test set or val config.isTest = True dataset = create_dataset(config=config) model = create_model(config) for j in range(0, 102, 1): config.load_iter = j model.setup() model.clear_precision() if config.eval: model.eval() dataset_size = len(dataset) print("test dataset len: %d " % dataset_size) total_iter = int(dataset_size / config.batch_size) model.set_validate_size(dataset_size) # fc_feature = np.zeros((dataset_size, 2048)) # label = np.zeros((dataset_size, 40)) for i, data in enumerate(dataset): model.set_input(data) print("[%s/%s]" % (i, total_iter)) model.test() print(model.get_model_precision()) print(model.get_model_class_balance_precision()) print("mean accuracy: {}".format(torch.mean(model.get_model_precision()))) print("class_balance accuracy: {}".format(torch.mean(model.get_model_class_balance_precision())))
def app(request): """ Returns session-wide application. """ logging.log(logging.INFO, TestConfig().SQLALCHEMY_DATABASE_URI) app = create_app(TestConfig()) return app
def _run(self, config: TestConfig): config.resolve(self.results) result = rest_client.request(config.url, config.method, config.content_type, config.body, config.headers, config.files) resolver = result_resolver.get_resolver(result, config.data_type) validate_result = resolver.validate(config.validates) if validate_result['result']: print('success') else: print(validate_result) result_dic = resolver.get_results(config.results) self.results[config.name] = result_dic
def test_file_logging(): ''' Make sure file logging is set up ''' file_config = TestConfig() file_config.TESTING = False file_config.FLASK_LOG_FILE = "/dev/null" file_config.FLASK_LOG_LEVEL = "INFO" with LogCapture() as test_logger: create_app(file_config) test_logger.check_present( ('app', 'INFO', 'NGS360 loading'), ('app', 'INFO', 'Setting up file logging to /dev/null'), ('app', 'INFO', 'NGS360 loaded.') )
def test_create_instance_with_invalid_configs(self): with self.subTest("with no local storage"): with self.assertRaises(InvalidConfigError): config = TestConfig() config.LOCAL_STORAGE_LOCATION = '' FileSystemStorage(config) with self.subTest("with a relative path"): with self.assertRaises(InvalidConfigError): config = TestConfig() config.LOCAL_STORAGE_LOCATION = '../../etc' FileSystemStorage(config) with self.subTest("with None config"): with self.assertRaises(InvalidConfigError): FileSystemStorage(None) with self.subTest("with valid config"): config = TestConfig() storage = FileSystemStorage(config) from decouple import config BASE_DIR = os.path.join( os.path.dirname(os.path.dirname(os.path.abspath(__file__))), '/test') self.assertEqual(storage.config.LOCAL_STORAGE_LOCATION, config('LOCAL_STORAGE_LOCATION'))
def setUp(self): #Config config = TestConfig() #Mock mock = MagicMock() mock.delete_object(Bucket=config.BUCKET_NAME, Key='d20b1c38-2f5f-4b48-b604-eb90f82ff800') config.S3 = mock #Storage self.storage = AWSStorage(config) self.config = config
def setUp(self): self.config = Config() self.app = create_app(self.config) self.test_client = self.app.test_client() with self.app.app_context(): db.create_all()
def setUp(self): test_config = TestConfig() self.app = create_app(test_config) self.app_context = self.app.app_context() self.app_context.push() self.client = self.app.test_client() db.create_all()
def get_config(): if FLAGS.model == "small": return SmallConfig() elif FLAGS.model == "test": return TestConfig() else: raise ValueError("Invalid model: %s", FLAGS.model)
def gatebot(): gatebot = GateBot(TestConfig()) gatebot.config.QUESTIONS_PER_QUIZ = 3 gatebot.config.CORRECT_ANSWERS_REQUIRED = 2 Base.metadata.create_all() return gatebot
def database(): from mox.data import Database config = TestConfig() db = Database(config) db.open() yield db db.rollback() db.close()
def main(env: str = None): if env == 'prod': config = ProductionConfig() elif env == 'test': config = TestConfig() else: print("Usage: python3 deploy.py --env=prod|test") return ecs = ECS(config_obj=config) ecs.run()
def test_email_logging(): ''' Make sure email logging is set up ''' email_config = TestConfig() email_config.TESTING = False email_config.MAIL_SERVER = "xyz" email_config.MAIL_PORT = 1 email_config.MAIL_USERNAME = "******" email_config.MAIL_PASSWORD = '' email_config.MAIL_USE_TLS = 1 email_config.ADMINS = "abc" with LogCapture() as test_logger: create_app(email_config) test_logger.check_present( ('app', 'INFO', 'NGS360 loading'), ('app', 'INFO', 'Setting up email logger'), ('app', 'INFO', 'NGS360 loaded.') )
def client(): from mox import create_app, Dependencies config = TestConfig() deps = Dependencies(config) client = create_app(deps).test_client() client.database = deps.database yield client deps.database.rollback() deps.database.close()
def setUp(self): #Config self.config = TestConfig() #Storage self.storage = FileSystemStorage(self.config) #Temp File self.file = tempfile.TemporaryFile(mode='w+b') self.file.write(b'It is a file!') self.file.seek(0) self.raw_file = self.file.read()
def create_app() -> Flask: """Create task runner app.""" # pylint: disable=W0621 app = Flask(__name__) if app.config["ENV"] == "development": try: from config_cust import DevConfig as DevConfigCust app.config.from_object(DevConfigCust()) except ImportError: from config import DevConfig app.config.from_object(DevConfig()) elif app.config["ENV"] == "test": try: from config_cust import ( TestConfig as TestConfigCust, # type: ignore[attr-defined] ) app.config.from_object(TestConfigCust()) except ImportError: from config import TestConfig app.config.from_object(TestConfig()) else: try: from config_cust import Config as ConfigCust app.config.from_object(ConfigCust()) except ImportError: from config import Config app.config.from_object(Config()) db.init_app(app) executor.init_app(app) redis_client.init_app(app) with app.app_context(): # pylint: disable=C0415 from runner.web import filters, web app.register_blueprint(web.web_bp) app.register_blueprint(filters.filters_bp) return app
def setUp(self): #Temp File self.file = tempfile.TemporaryFile(mode='w+b') self.file.write(b'It is a file!') self.file.seek(0) self.raw_file = self.file.read() #Config config = TestConfig() #Mock mock = MagicMock() mock.put_object(Bucket=config.BUCKET_NAME, Key='d20b1c38-2f5f-4b48-b604-eb90f82ff800', Body=b'It is a file!') config.S3 = mock #Storage self.storage = AWSStorage(config) self.config = config
def create_app(type="app", test=False): app = Flask(__name__) cfg = DevConfig() if test: cfg = TestConfig() app.config.from_object(cfg) configure_celery(app, tasks.celery) init_mongo(app) register_error_handlers(app) register_routes(app) return app if type == "app" else tasks.celery
def create_app(test_config=False): app = Flask(__name__) config = TestConfig() if test_config else BaseConfig() app.config.from_object(config) app.register_blueprint(api_blueprint) jwt = JWTManager() jwt.init_app(app) db.init_app(app) migrate = Migrate(app, db) logging.basicConfig( format='%(asctime)s - %(name)s:%(message)s', filename=Path(__file__, '../../app.log').resolve(), level=logging.DEBUG, ) return app
def app(): app = create_app() config = TestConfig() app.config.from_object(config) return app
def app(): ''' Set test App context ''' app = create_app() config = TestConfig() app.config.from_object(config) return app
def setUp(self): self.verifyString = 'test' self.config = TestConfig()
def __init__(self, burnin, enable_eth_tests, enable_modem_test=0, **kw): self._burnin = burnin self._preflight_done = 0 # DO NOT CHANGE THE ORDER OF THESE THREE ITEMS! Thank you! self._config = TestConfig(burnin, '/etc/hw_test.conf') self._hw_info = HardwareInfo() self._logger = TestLogger(burnin, self._hw_info.serialno()) self._bootlog_tester = None self._car_tester = None self._dallas_tester = None self._eth_tester = None self._i2c_tester = None self._mem_tester = None self._stressmemtester = None self._modem_tester = None self._serial_tester = None self._usb_tester = None self._enabled_tests = 0 model = self._hw_info.model() if kw.get('bootlog', True): self._bootlog_tester = BootlogTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if kw.get('ram', True): self._mem_tester = MemoryTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 # do not perform stress test unless called for explicitly. if kw.get('ramstress', False): self._stressmemtester = MemoryTester( self._config, self._hw_info, self._logger, True ) self._enabled_tests += 1 if enable_eth_tests and kw.get('ethernet', True): self._eth_tester = NetworkTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if not model in ('TSWS', 'PC', 'Unknown', ''): self._avr_copro = avr() if kw.get('serial', True): self._serial_tester = SerialTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if model in ('1200', '2400', '1500', '2500'): if kw.get('relayscounters', True): self._car_tester = CountersAndRelaysTester( self._config, self._hw_info, self._logger, self._avr_copro ) self._enabled_tests += 1 if kw.get('dallas', True): self._dallas_tester = DallasTester( self._config, self._hw_info, self._logger, self._avr_copro ) self._enabled_tests += 1 if model in ('1500', '2500') and kw.get('i2c', True): self._i2c_tester = I2CTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if self._hw_info.model() in ('2400', '2500') and kw.get('usb', True): self._usb_tester = USBTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 return
class TesterFramework(object): def __init__(self, burnin, enable_eth_tests, enable_modem_test=0, **kw): self._burnin = burnin self._preflight_done = 0 # DO NOT CHANGE THE ORDER OF THESE THREE ITEMS! Thank you! self._config = TestConfig(burnin, '/etc/hw_test.conf') self._hw_info = HardwareInfo() self._logger = TestLogger(burnin, self._hw_info.serialno()) self._bootlog_tester = None self._car_tester = None self._dallas_tester = None self._eth_tester = None self._i2c_tester = None self._mem_tester = None self._stressmemtester = None self._modem_tester = None self._serial_tester = None self._usb_tester = None self._enabled_tests = 0 model = self._hw_info.model() if kw.get('bootlog', True): self._bootlog_tester = BootlogTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if kw.get('ram', True): self._mem_tester = MemoryTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 # do not perform stress test unless called for explicitly. if kw.get('ramstress', False): self._stressmemtester = MemoryTester( self._config, self._hw_info, self._logger, True ) self._enabled_tests += 1 if enable_eth_tests and kw.get('ethernet', True): self._eth_tester = NetworkTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if not model in ('TSWS', 'PC', 'Unknown', ''): self._avr_copro = avr() if kw.get('serial', True): self._serial_tester = SerialTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if model in ('1200', '2400', '1500', '2500'): if kw.get('relayscounters', True): self._car_tester = CountersAndRelaysTester( self._config, self._hw_info, self._logger, self._avr_copro ) self._enabled_tests += 1 if kw.get('dallas', True): self._dallas_tester = DallasTester( self._config, self._hw_info, self._logger, self._avr_copro ) self._enabled_tests += 1 if model in ('1500', '2500') and kw.get('i2c', True): self._i2c_tester = I2CTester( self._config, self._hw_info, self._logger ) self._enabled_tests += 1 if self._hw_info.model() in ('2400', '2500') and kw.get('usb', True): self._usb_tester = USBTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 return ### # Do a single pass test over all tests except the boot log. # # XXX: iteration is unused for now, just a placeholder. def _core_test(self, iteration): if not self._preflight_done: raise Exception("Pre-test checkout has not been done, aborting.\n") if self._car_tester: self._car_tester.runtest(self._burnin) if self._dallas_tester: self._dallas_tester.runtest(self._burnin) if self._eth_tester: self._eth_tester.runtest(1) # burnin set to 1 to avoid netperf tests if self._i2c_tester: self._i2c_tester.runtest(self._burnin) if self._mem_tester: self._mem_tester.runtest(self._burnin) if self._stressmemtester: self._stressmemtester.runtest(self._burnin) if self._modem_tester: self._modem_tester.runtest(self._burnin) if self._serial_tester: self._serial_tester.runtest(self._burnin) if self._usb_tester: self._usb_tester.runtest(self._burnin) return ### # Make sure that we have a valid serial number, and: # - If in burn-in mode we don't have one, do not test. # - If in production mode, get this info using a barcode scanner # and program the serial number and mac address(es). def preflight_check(self): if self._preflight_done: return 1 serialRE = re.compile("\d{2}-\d{5}", re.IGNORECASE) result = serialRE.search(self._hw_info.serialno()) if result: self._preflight_done = 1 return 1 message('This unit needs a serial number and MAC address(es).') if self._burnin: message('Burn-in tests cannot be done on brand-new units.') return 0 msg_testing('One moment while a connection is made to the HW test server...') m_address = self._config.def_macaddr() self._hw_info.set_mac_addr(0, m_address) os.system('ifconfig eth0 down') #os.system('rmmod natsemi; sleep 1; insmod -q natsemi') if_mac_addr = '%s:%s:%s:%s:%s:%s' % \ (m_address[0:2], m_address[2:4], m_address[4:6], m_address[6:8], m_address[8:10], m_address[10:]) os.system('ifconfig eth0 hw ether %s' % if_mac_addr) os.system('ifconfig eth0 %s up' % self._config.def_ipaddr()) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect((self._config.hwtest_server(), self._config.hwtest_port())) except: msg_fail() return 0 message('done.\nYou may now scan the barcode on this unit.') # Send a hello message and then go into a wait. s.send('GreetZ_1138') data = s.recv(64) s.close() serial, mac0, mac1 = data.split(":") # Any of the following set_xxx calls will raise an exception on failure. msg_testing('Programming the serial number and MAC address(es) for this unit...') self._hw_info.set_serialno(serial) self._hw_info.set_mac_addr(0, mac0) if not mac1 == "": self._hw_info.set_mac_addr(1, mac1) message('done.') msg_testing('Restarting networking...') self._hw_info.restart_networking() self._hw_info.reload_values() message('done.') self._preflight_done = 1 return 1 def print_prerun_summary(self): if self._enabled_tests <= 1: return self._logger.msg('Mediator hardware test program revision %s.\n', hwtest_version()) self._logger.msg('Copyright (C) 2009 Cisco Systems, Inc. All rights reserved.\n\n') self._logger.msg('Test executed on %s\n' % os.popen('date').readline()) self._logger.msg('Model number: %s\n' % self._hw_info.model()) self._logger.msg('Framework version: %s\n' % properties.COMPOUND_VERSION) self._logger.msg('MOE version: %s\n' % properties.MOE_VERSION) self._logger.msg('Serial number: %s\n' % self._hw_info.serialno()) self._logger.msg('eth0 MAC address: %s\n' % self._hw_info.mac_addr(0)) if self._hw_info.model() in ('TSWS', '2400', '2500'): self._logger.msg('eth1 MAC address: %s\n' % self._hw_info.mac_addr(1)) ### # Having a list of loaded modules will be extremely helpful in the # event a test should fail (because the module might not have loaded). self._logger.msg('Loaded kernel modules:\n') result, spewage = execute_command('/sbin/lsmod') if not result: raise Exception('Cannot get module info, aborting test.') for line in spewage: self._logger.msg(line) self._logger.msg('\n') return def tests_in_error(self): errs = 0 if self._bootlog_tester: errs += self._bootlog_tester.nissues() if self._car_tester: errs += self._car_tester.nissues() if self._dallas_tester: errs += self._dallas_tester.nissues() if self._eth_tester: errs += self._eth_tester.nissues() if self._i2c_tester: errs += self._i2c_tester.nissues() if self._mem_tester: errs += self._mem_tester.nissues() if self._modem_tester: errs += self._modem_tester.nissues() if self._serial_tester: errs += self._serial_tester.nissues() if self._usb_tester: errs += self._usb_tester.nissues() return errs def report_results(self): if self._enabled_tests > 1: self._logger.msg('Test summary for unit %s:\n' % self._hw_info.serialno()) # NOTE NOTE NOTE NOTE NOTE NOTE =--------------------------------- # # Please report results in the order that the tests are done. # Like muscle memory, folks can develop visual memory as well. # # NOTE NOTE NOTE NOTE NOTE NOTE =--------------------------------- if self._bootlog_tester: self._bootlog_tester.print_results() if self._car_tester: self._car_tester.print_results() if self._dallas_tester: self._dallas_tester.print_results() if self._eth_tester: self._eth_tester.print_results() if self._i2c_tester: self._i2c_tester.print_results() if self._mem_tester: self._mem_tester.print_results() if self._modem_tester: self._modem_tester.print_results() if self._serial_tester: self._serial_tester.print_results() if self._usb_tester: self._usb_tester.print_results() if self._enabled_tests > 1: self._logger.msg("=----- END OF REPORT ------------------------------=\n\n") ### # Examine the boot log and run all core tests once. def runtests(self): if not self._preflight_done: raise Exception("Pre-test checkout has not been done, aborting.\n") if self._bootlog_tester: self._bootlog_tester.runtest(self._burnin) self._core_test(1) return
def app(): """ Application Ficture """ app = create_app() config = TestConfig() app.config.from_object(config) return app
class TesterFramework(object): def __init__(self, burnin, enable_eth_tests, enable_modem_test=0, **kw): self._burnin = burnin self._preflight_done = 0 # DO NOT CHANGE THE ORDER OF THESE THREE ITEMS! Thank you! self._config = TestConfig(burnin, '/etc/hw_test.conf') self._hw_info = HardwareInfo() self._logger = TestLogger(burnin, self._hw_info.serialno()) self._bootlog_tester = None self._car_tester = None self._dallas_tester = None self._eth_tester = None self._i2c_tester = None self._mem_tester = None self._stressmemtester = None self._modem_tester = None self._serial_tester = None self._usb_tester = None self._enabled_tests = 0 model = self._hw_info.model() if kw.get('bootlog', True): self._bootlog_tester = BootlogTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if kw.get('ram', True): self._mem_tester = MemoryTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 # do not perform stress test unless called for explicitly. if kw.get('ramstress', False): self._stressmemtester = MemoryTester(self._config, self._hw_info, self._logger, True) self._enabled_tests += 1 if enable_eth_tests and kw.get('ethernet', True): self._eth_tester = NetworkTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if not model in ('TSWS', 'PC', 'Unknown', ''): self._avr_copro = avr() if kw.get('serial', True): self._serial_tester = SerialTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if model in ('1200', '2400', '1500', '2500'): if kw.get('relayscounters', True): self._car_tester = CountersAndRelaysTester( self._config, self._hw_info, self._logger, self._avr_copro) self._enabled_tests += 1 if kw.get('dallas', True): self._dallas_tester = DallasTester(self._config, self._hw_info, self._logger, self._avr_copro) self._enabled_tests += 1 if model in ('1500', '2500') and kw.get('i2c', True): self._i2c_tester = I2CTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if self._hw_info.model() in ('2400', '2500') and kw.get('usb', True): self._usb_tester = USBTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 return ### # Do a single pass test over all tests except the boot log. # # XXX: iteration is unused for now, just a placeholder. def _core_test(self, iteration): if not self._preflight_done: raise Exception("Pre-test checkout has not been done, aborting.\n") if self._car_tester: self._car_tester.runtest(self._burnin) if self._dallas_tester: self._dallas_tester.runtest(self._burnin) if self._eth_tester: self._eth_tester.runtest( 1) # burnin set to 1 to avoid netperf tests if self._i2c_tester: self._i2c_tester.runtest(self._burnin) if self._mem_tester: self._mem_tester.runtest(self._burnin) if self._stressmemtester: self._stressmemtester.runtest(self._burnin) if self._modem_tester: self._modem_tester.runtest(self._burnin) if self._serial_tester: self._serial_tester.runtest(self._burnin) if self._usb_tester: self._usb_tester.runtest(self._burnin) return ### # Make sure that we have a valid serial number, and: # - If in burn-in mode we don't have one, do not test. # - If in production mode, get this info using a barcode scanner # and program the serial number and mac address(es). def preflight_check(self): if self._preflight_done: return 1 serialRE = re.compile("\d{2}-\d{5}", re.IGNORECASE) result = serialRE.search(self._hw_info.serialno()) if result: self._preflight_done = 1 return 1 message('This unit needs a serial number and MAC address(es).') if self._burnin: message('Burn-in tests cannot be done on brand-new units.') return 0 msg_testing( 'One moment while a connection is made to the HW test server...') m_address = self._config.def_macaddr() self._hw_info.set_mac_addr(0, m_address) os.system('ifconfig eth0 down') #os.system('rmmod natsemi; sleep 1; insmod -q natsemi') if_mac_addr = '%s:%s:%s:%s:%s:%s' % \ (m_address[0:2], m_address[2:4], m_address[4:6], m_address[6:8], m_address[8:10], m_address[10:]) os.system('ifconfig eth0 hw ether %s' % if_mac_addr) os.system('ifconfig eth0 %s up' % self._config.def_ipaddr()) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: s.connect( (self._config.hwtest_server(), self._config.hwtest_port())) except: msg_fail() return 0 message('done.\nYou may now scan the barcode on this unit.') # Send a hello message and then go into a wait. s.send('GreetZ_1138') data = s.recv(64) s.close() serial, mac0, mac1 = data.split(":") # Any of the following set_xxx calls will raise an exception on failure. msg_testing( 'Programming the serial number and MAC address(es) for this unit...' ) self._hw_info.set_serialno(serial) self._hw_info.set_mac_addr(0, mac0) if not mac1 == "": self._hw_info.set_mac_addr(1, mac1) message('done.') msg_testing('Restarting networking...') self._hw_info.restart_networking() self._hw_info.reload_values() message('done.') self._preflight_done = 1 return 1 def print_prerun_summary(self): if self._enabled_tests <= 1: return self._logger.msg('Mediator hardware test program revision %s.\n', hwtest_version()) self._logger.msg( 'Copyright (C) 2009 Cisco Systems, Inc. All rights reserved.\n\n') self._logger.msg('Test executed on %s\n' % os.popen('date').readline()) self._logger.msg('Model number: %s\n' % self._hw_info.model()) self._logger.msg('Framework version: %s\n' % properties.COMPOUND_VERSION) self._logger.msg('MOE version: %s\n' % properties.MOE_VERSION) self._logger.msg('Serial number: %s\n' % self._hw_info.serialno()) self._logger.msg('eth0 MAC address: %s\n' % self._hw_info.mac_addr(0)) if self._hw_info.model() in ('TSWS', '2400', '2500'): self._logger.msg('eth1 MAC address: %s\n' % self._hw_info.mac_addr(1)) ### # Having a list of loaded modules will be extremely helpful in the # event a test should fail (because the module might not have loaded). self._logger.msg('Loaded kernel modules:\n') result, spewage = execute_command('/sbin/lsmod') if not result: raise Exception('Cannot get module info, aborting test.') for line in spewage: self._logger.msg(line) self._logger.msg('\n') return def tests_in_error(self): errs = 0 if self._bootlog_tester: errs += self._bootlog_tester.nissues() if self._car_tester: errs += self._car_tester.nissues() if self._dallas_tester: errs += self._dallas_tester.nissues() if self._eth_tester: errs += self._eth_tester.nissues() if self._i2c_tester: errs += self._i2c_tester.nissues() if self._mem_tester: errs += self._mem_tester.nissues() if self._modem_tester: errs += self._modem_tester.nissues() if self._serial_tester: errs += self._serial_tester.nissues() if self._usb_tester: errs += self._usb_tester.nissues() return errs def report_results(self): if self._enabled_tests > 1: self._logger.msg('Test summary for unit %s:\n' % self._hw_info.serialno()) # NOTE NOTE NOTE NOTE NOTE NOTE =--------------------------------- # # Please report results in the order that the tests are done. # Like muscle memory, folks can develop visual memory as well. # # NOTE NOTE NOTE NOTE NOTE NOTE =--------------------------------- if self._bootlog_tester: self._bootlog_tester.print_results() if self._car_tester: self._car_tester.print_results() if self._dallas_tester: self._dallas_tester.print_results() if self._eth_tester: self._eth_tester.print_results() if self._i2c_tester: self._i2c_tester.print_results() if self._mem_tester: self._mem_tester.print_results() if self._modem_tester: self._modem_tester.print_results() if self._serial_tester: self._serial_tester.print_results() if self._usb_tester: self._usb_tester.print_results() if self._enabled_tests > 1: self._logger.msg( "=----- END OF REPORT ------------------------------=\n\n") ### # Examine the boot log and run all core tests once. def runtests(self): if not self._preflight_done: raise Exception("Pre-test checkout has not been done, aborting.\n") if self._bootlog_tester: self._bootlog_tester.runtest(self._burnin) self._core_test(1) return
def setUp(self): #Config self.config = TestConfig() #Storage self.storage = FileSystemStorage(self.config)
X = X[:, :, ::-1] X = np.expand_dims(X, axis=0) X = X.astype('float32') X -= self.X_mean X /= 255.0 return self.model.predict(X)[0] face_dataset = intrusion_data(csv_file='interpolated_2188to16447_attack_a_0p2_0p9_9982.csv',root_dir='/home/pi/new_try_raspberry_pi--/chen_data_try/chen_new_try/chen_new_data',cs=1,transform=transforms.Compose([transforms.Resize(256),transforms.RandomResizedCrop(224),transforms.ToTensor()])) test_dataset=intrusion_data(csv_file='interpolated_2188to16447_attack_a_0p2_0p9_4280.csv',root_dir='/home/pi/new_try_raspberry_pi--/chen_data_try/chen_new_try/chen_new_data',cs=1,transform=transforms.Compose([transforms.Resize(256),transforms.RandomResizedCrop(224),transforms.ToTensor()])) dataloader = DataLoader(face_dataset, batch_size=1, shuffle=False) test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False) config = TestConfig() ch = config.num_channels row = config.img_height col = config.img_width model_org = create_comma_model_large_dropout(row, col, ch, load_weights=True) model = Model(model_org, "data/X_train_gray_diff2_mean.npy") net = mynet() criterion = F.nll_loss optimizer = optim.Adam(net.parameters(), lr=0.01) def accuracy(act , out):
def __init__(self, burnin, enable_eth_tests, enable_modem_test=0, **kw): self._burnin = burnin self._preflight_done = 0 # DO NOT CHANGE THE ORDER OF THESE THREE ITEMS! Thank you! self._config = TestConfig(burnin, '/etc/hw_test.conf') self._hw_info = HardwareInfo() self._logger = TestLogger(burnin, self._hw_info.serialno()) self._bootlog_tester = None self._car_tester = None self._dallas_tester = None self._eth_tester = None self._i2c_tester = None self._mem_tester = None self._stressmemtester = None self._modem_tester = None self._serial_tester = None self._usb_tester = None self._enabled_tests = 0 model = self._hw_info.model() if kw.get('bootlog', True): self._bootlog_tester = BootlogTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if kw.get('ram', True): self._mem_tester = MemoryTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 # do not perform stress test unless called for explicitly. if kw.get('ramstress', False): self._stressmemtester = MemoryTester(self._config, self._hw_info, self._logger, True) self._enabled_tests += 1 if enable_eth_tests and kw.get('ethernet', True): self._eth_tester = NetworkTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if not model in ('TSWS', 'PC', 'Unknown', ''): self._avr_copro = avr() if kw.get('serial', True): self._serial_tester = SerialTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if model in ('1200', '2400', '1500', '2500'): if kw.get('relayscounters', True): self._car_tester = CountersAndRelaysTester( self._config, self._hw_info, self._logger, self._avr_copro) self._enabled_tests += 1 if kw.get('dallas', True): self._dallas_tester = DallasTester(self._config, self._hw_info, self._logger, self._avr_copro) self._enabled_tests += 1 if model in ('1500', '2500') and kw.get('i2c', True): self._i2c_tester = I2CTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 if self._hw_info.model() in ('2400', '2500') and kw.get('usb', True): self._usb_tester = USBTester(self._config, self._hw_info, self._logger) self._enabled_tests += 1 return