Beispiel #1
0
def client():
    logging.log(logging.INFO, TestConfig().SQLALCHEMY_DATABASE_URI)

    app = create_app(TestConfig())
    client = app.test_client()

    yield client
Beispiel #2
0
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
Beispiel #4
0
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
Beispiel #5
0
 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)
Beispiel #6
0
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
Beispiel #7
0
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())))
Beispiel #8
0
def app(request):
    """
    Returns session-wide application.
    """
    logging.log(logging.INFO, TestConfig().SQLALCHEMY_DATABASE_URI)
    app = create_app(TestConfig())

    return app
Beispiel #9
0
 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
Beispiel #10
0
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
Beispiel #13
0
    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()
Beispiel #14
0
    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()
Beispiel #15
0
 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()
Beispiel #16
0
def get_config():
    if FLAGS.model == "small":
        return SmallConfig()
    elif FLAGS.model == "test":
        return TestConfig()
    else:
        raise ValueError("Invalid model: %s", FLAGS.model)
Beispiel #17
0
def gatebot():
    gatebot = GateBot(TestConfig())
    gatebot.config.QUESTIONS_PER_QUIZ = 3
    gatebot.config.CORRECT_ANSWERS_REQUIRED = 2

    Base.metadata.create_all()

    return gatebot
Beispiel #18
0
def database():
    from mox.data import Database
    config = TestConfig()
    db = Database(config)
    db.open()
    yield db
    db.rollback()
    db.close()
Beispiel #19
0
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()
Beispiel #20
0
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.')
        )
Beispiel #21
0
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
Beispiel #25
0
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
Beispiel #26
0
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
Beispiel #27
0
def app():
    app = create_app()
    config = TestConfig()
    app.config.from_object(config)
    return app
Beispiel #28
0
def app():
    ''' Set test App context '''
    app = create_app()
    config = TestConfig()
    app.config.from_object(config)
    return app
Beispiel #29
0
 def setUp(self):
     self.verifyString = 'test'
     self.config = TestConfig()
Beispiel #30
0
    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
Beispiel #31
0
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
Beispiel #32
0
def app():
    """ Application Ficture """
    app = create_app()
    config = TestConfig()
    app.config.from_object(config)
    return app
Beispiel #33
0
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)
Beispiel #35
0
            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):
Beispiel #36
0
    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