Esempio n. 1
0
    def run_tests(self, tests_mapping):
        """ run testcase/testsuite data
        """
        # parse tests
        parsed_tests_mapping = parse.parse_tests(tests_mapping)

        # add tests to test suite
        test_suite = self._add_tests(parsed_tests_mapping)

        # run test suite
        cur_path = os.path.dirname(__file__)
        conf_path = os.path.join(cur_path, 'conf/conf.ini')
        conf = Conf(conf_path)
        try:
            REPORT_DIR = conf.get_value('data_addr', 'report_addr')
        except (configparser.NoSectionError, configparser.NoOptionError):
            REPORT_DIR = os.path.join(cur_path, 'report/')

        if not os.path.exists(REPORT_DIR):
            os.makedirs(REPORT_DIR)

        filename = os.path.join(
            REPORT_DIR,
            time.strftime('%Y%m%d%H%M%S', time.localtime()) +
            '_api_report.html')  # 定义个报告存放路径,支持相对路径
        f = open(filename, 'wb')  # 结果写入HTML 文件
        runner = HTMLTestRunner.HTMLTestRunner(
            stream=f,
            title='api_report',
            description='Report_description',
            verbosity=2)  # 使用HTMLTestRunner配置参数,输出报告路径、报告标题、描述
        runner.run(test_suite)
Esempio n. 2
0
def exec_file(file, answer):
    """
    Execute a file and get similarity between ground truth

    Args:
    * file
        File to execute
    * answer
        Ground truth file to compare output to
    
    Returns:
    """
    # Run the given file
    runner.run(file)

    # Get file name without extension to find 
    # output file and to compare to answer
    # ex: test.java --> find test.out.txt
    name = os.path.splitext(file.split(sep)[-1])[0]
    out = name + ".out.txt"

    # Compare differences
    diff = get_diff(out, answer)

    return(str(diff) + "%\n")
Esempio n. 3
0
def main():
    # Add seed
    random_seed = 42
    torch.manual_seed(random_seed)
    args = parser.get()
    X_train = load('./datas/X_train.npy')
    y_train = load('./datas/y_train.npy')
    X_test = load('./datas/X_test.npy')
    train_dataset = data.DatasetXy(X_train, y_train)
    test_dataset = data.DatasetX(X_test)
    data_class = data.Dataloader(args, train_dataset, test_dataset)

    train, test = data_class.train(), data_class.test()

    model = models.get(args)
    optimizer = optimizers.get(args, model.parameters())
    criterion = torch.nn.CrossEntropyLoss()

    for epoch in range(args.epochs):
        train_metrics = runner.run(
            model,
            criterion,
            optimizer,
            train,
            True,
            {
                "loss": metrics.loss,
                "accuracy": metrics.accuracy
            },
        )
        metrics.print_metrics(train_metrics)

    y_test_pred = runner.run(
        model,
        criterion,
        optimizer,
        test,
        False,
        {
            "loss": metrics.loss,
            "accuracy": metrics.accuracy
        },
    )

    print(y_test_pred)
    y_test_pred = [item for sublist in y_test_pred for item in sublist]
    #print((y_test_pred[0]).shape)
    #_, y_pred = torch.max(y_test_pred, dim = 1)

    #y_pred = torch.round(y_test_pred)
    # _, y_pred = torch.max(y_test_pred, dim = 1)
    # y_pred = y_pred.cpu().numpy()
    #print(len(y_pred_list))
    #print(y_pred.type)
    y_test = np.asarray(y_test_pred)
    pd.DataFrame({
        "Id": np.arange(len(y_test)),
        "Category": y_test
    }).astype(int).to_csv("solution.csv", index=False)
Esempio n. 4
0
def test_access_environ():
    mock_logger = Mock()
    command = 'cat /proc/1/environ'
    env = {}

    run(mock_logger, command, env=env)

    mock_logger.info.assert_any_call('cat: /proc/1/environ: Permission denied')
Esempio n. 5
0
  def test_app_help(self):
    (noArg, result) = run()
    (arg, result) = run(['--help', 'ignored', 'arguments'])

    usageText = f'Usage: {app_name()} [options] file [options] [time1 time2 ...]\nOptions:\n  --version         Print program version and exit.\n  --help            Print usage information and exit.\n  -v                Verbose; print the current total in a human friendly way.\n                    It\'s only active when reading.\nExample:\n  {app_name()} log.txt 1:27 -11:01 +2:15:23 127\n'

    self.assertEqual(noArg, usageText)
    self.assertEqual(arg, usageText)
Esempio n. 6
0
def test_register_list_unregister_device():
    ret = run("registry --register --events pollution --device")

    uuid = ret.split()[1]
    ret = run("registry --list --device")

    assert uuid in ret

    run("registry --unregister --uuid " + uuid)
Esempio n. 7
0
def main(
    debug: bool,
    cpu_time: int,
    real_time: int,
    memory: int,
    stack: int,
    output_size: int,
    process: int,
    input: str,
    output: str,
    error: str,
    log: str,
    uid: int,
    gid: int,
    use_path_env: bool,
    no_memory_limit: bool,
    console_log: bool,
    command: list,
):
    """Run your commands in the sandbox."""
    logger = logging.getLogger(logger_name)
    formatter = logging.Formatter(
        '%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d [%(process)d:%(funcName)s] %(message)s'
    )
    if log == '' or console_log:
        log_handler = logging.StreamHandler(sys.stderr)
        log_handler.setFormatter(formatter)
        logger.addHandler(log_handler)
    if log != '':
        file_handler = logging.FileHandler(log)
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)
    if debug:
        logger.setLevel(logging.DEBUG)
    else:
        logger.setLevel(logging.INFO)
    logger.info('UniJudge Sandbox Runner')
    logger.info('Version 0.0.1')
    logger.debug('Command: [%s]' % ', '.join(command))
    if len(command) == 0:
        logger.fatal('Cannot find command')
        exit(1)
    limit = ResourceLimit(cpu_time=cpu_time,
                          real_time=real_time,
                          memory=memory,
                          stack=stack,
                          output_size=output_size,
                          process=process,
                          no_memory_limit=no_memory_limit)
    redirect = Redirect(
        stdin=input,
        stdout=output,
        stderr=error,
    )
    logger.debug(asdict(limit).__str__())
    logger.debug(asdict(redirect).__str__())
    run(command, limit, redirect, use_path_env)
def test_subscriber_exit_after():
    def subscriber():
        run("subscriber --traffic --exit-after 2")

    def injector():
        run("injectors --run --event traffic --duration 0.02")

    run("registry --init")
    parallel_run([subscriber, injector], lambda func, thread: func())
Esempio n. 9
0
def test_citypulse_pollution_download():
    run("datasets --download --dataset citypulse --event pollution")

    import embers.datasets.citypulse.pollution as pollution
    t = pollution.Pollution()
    s = t.get_source(0)
    d = s.next()

    assert "carbon_monoxide" in d
    assert "nitrogen_dioxide" in d
Esempio n. 10
0
def playbook(name, config, extra_vars=None, retries=0, delay=0, delay_factor=1):
    """Playbook must be located in ansible_data/playbooks"""
    playbook = _get_playbook_args(name, config, extra_vars)

    cwd = os.getcwd() # Need this to use ansible.cfg
    os.chdir(ANSIBLE_PATH)
    print("Running {}".format(playbook))
    runner.run(playbook,
        retries=retries, delay=delay, delay_factor=delay_factor)
    os.chdir(cwd)
Esempio n. 11
0
def destroy(network_config):
    env_vars = _create_env_vars(network_config)
    state_flag = _create_state_flag(network_config)

    cwd = os.getcwd()
    os.chdir(TF_PATH)

    # Destory
    runner.run(['terraform', 'destroy'] + env_vars + state_flag + ['--force'])

    os.chdir(cwd)
Esempio n. 12
0
def do(args):
    # ip = ansible.get_node_ip(args.node, args.id)
    config = network.config.load(args.id)
    ip = tf.get_node_ip(args.node, config)

    cwd = os.getcwd()  # Need this to use ansible.cfg
    os.chdir(BIN_PATH)

    runner.run(
        [os.path.join(BIN_PATH, "init_bond"), config['sawtooth_path'], ip])
    os.chdir(cwd)
Esempio n. 13
0
def download_hugo():
    logger = get_logger('download-hugo')

    HUGO_VERSION_PATH = CLONE_DIR_PATH / HUGO_VERSION
    if HUGO_VERSION_PATH.is_file():
        logger.info('.hugo-version found')
        hugo_version = ''
        with HUGO_VERSION_PATH.open() as hugo_vers_file:
            try:
                hugo_version = hugo_vers_file.readline().strip()
                hugo_version = shlex.quote(hugo_version)
                regex = r'^(extended_)?[\d]+(\.[\d]+)*$'
                hugo_version = re.search(regex, hugo_version).group(0)
            except Exception:
                raise RuntimeError('Invalid .hugo-version')

        if hugo_version:
            logger.info(f'Using hugo version in .hugo-version: {hugo_version}')
    else:
        raise RuntimeError(".hugo-version not found")
    '''
    Downloads the specified version of Hugo
    '''
    logger.info(f'Downloading hugo version {hugo_version}')
    failed_attempts = 0
    while (failed_attempts < 5):
        try:
            dl_url = ('https://github.com/gohugoio/hugo/releases/download/v' +
                      hugo_version.split('_')[-1] +
                      f'/hugo_{hugo_version}_Linux-64bit.tar.gz')
            response = requests.get(dl_url, verify=CERTS_PATH)

            hugo_tar_path = WORKING_DIR_PATH / 'hugo.tar.gz'
            with hugo_tar_path.open('wb') as hugo_tar:
                for chunk in response.iter_content(chunk_size=128):
                    hugo_tar.write(chunk)

            HUGO_BIN_PATH = WORKING_DIR_PATH / HUGO_BIN
            run(logger,
                f'tar -xzf {hugo_tar_path} -C {WORKING_DIR_PATH}',
                env={},
                check=True)
            run(logger, f'chmod +x {HUGO_BIN_PATH}', env={}, check=True)
            return 0
        except Exception:
            failed_attempts += 1
            logger.info(
                f'Failed attempt #{failed_attempts} to download hugo version: {hugo_version}'
            )
            if failed_attempts == 5:
                raise RuntimeError(
                    f'Unable to download hugo version: {hugo_version}')
            time.sleep(2)  # try again in 2 seconds
Esempio n. 14
0
def check_and_run(rss_url, jenkins_id_file, do_force=False, do_loop=False):
    if (not os.path.exists(jenkins_id_file)) or do_force:
        with open(jenkins_id_file, 'w') as file:
            file.write('0')

    while True:
        # read jenkins id
        try:
            with open(jenkins_id_file) as file:
                old_id = int(file.read())
        except (TypeError, ValueError, FileNotFoundError):
            old_id = -1

        # check jenkins rss
        try:
            jenkins_rss = JenkinsRss(rss_url, old_id)
        except Exception:
            print('rss connect failed')
            if do_loop:
                print('trying again.')
                time.sleep(60)
                continue
            else:
                break

        if jenkins_rss.is_stable and jenkins_rss.is_new:
            # download apk
            apk_url = jenkins_rss.get_apk_link()
            res = requests.get(apk_url)
            with open(apk_file, 'wb') as file:
                file.write(res.content)

            # do testing
            try:
                runner.run(project_name=jenkins_rss.project_name,
                           build_id=jenkins_rss.build_id)
            except Exception as err:
                print('error occured when run tests:')
                print(err)
                if do_loop:
                    time.sleep(60)
                    continue
                else:
                    break

            # update jenkins id
            with open(jenkins_id_file, 'w') as file:
                file.write(str(jenkins_rss.build_id))
        if do_loop:
            time.sleep(60)
        else:
            break
Esempio n. 15
0
def test_citypulse_traffic_download():
    run("datasets --download --dataset citypulse --event traffic")

    import os
    assert os.path.isdir("embers.datasets.citypulse")

    import embers.datasets.citypulse.traffic as traffic
    t = traffic.Traffic()
    s = t.get_source(0)
    d = s.next()

    assert "vehicleCount" in d
    assert "avgSpeed" in d
Esempio n. 16
0
    def test_prelude(self) -> None:
        env = bytecode.EvalEnv()
        runner.add_intrinsics(env)
        runner.add_builtins(env)
        runner.add_prelude(env)

        self.assertEqual(
            run(env, "(= (cons 42 (cons 13 (cons 'a []))) '(42 13 a))"),
            SBool(True))
        self.assertEqual(
            run(env, "(= [1 2 [3 4 5] 6 [[7]]] [1 2 [3 4 5] 6 [[7]]])"),
            SBool(True))
        self.assertEqual(
            run(env, "(= [1 2 [3 4 5] 6 [[7]]] [1 2 [3 4 5] 6 [[7]]])"),
            SBool(True))
Esempio n. 17
0
def build_jekyll(branch,
                 owner,
                 repository,
                 site_prefix,
                 base_url='',
                 config='',
                 user_env_vars=[]):
    '''
    Builds the cloned site with Jekyll
    '''
    logger = get_logger('build-jekyll')

    JEKYLL_CONF_YML_PATH = CLONE_DIR_PATH / JEKYLL_CONFIG_YML

    # Add baseurl, branch, and the custom config to _config.yml.
    # Use the 'a' option to create or append to an existing config file.
    with JEKYLL_CONF_YML_PATH.open('a') as jekyll_conf_file:
        jekyll_conf_file.writelines([
            '\n'
            f'baseurl: {base_url}\n',
            f'branch: {branch}\n',
            config,
            '\n',
        ])

    jekyll_cmd = 'jekyll'

    GEMFILE_PATH = CLONE_DIR_PATH / GEMFILE
    if GEMFILE_PATH.is_file():
        jekyll_cmd = f'bundle exec {jekyll_cmd}'

    run(logger,
        f'echo Building using Jekyll version: $({jekyll_cmd} -v)',
        cwd=CLONE_DIR_PATH,
        env={},
        check=True,
        ruby=True)

    env = build_env(branch, owner, repository, site_prefix, base_url,
                    user_env_vars)
    env['JEKYLL_ENV'] = 'production'

    return run(logger,
               f'{jekyll_cmd} build --destination {SITE_BUILD_DIR_PATH}',
               cwd=CLONE_DIR_PATH,
               env=env,
               node=True,
               ruby=True)
Esempio n. 18
0
def test_cs_add_two_numbers_code():
    out = run(cs_source_code_add_two_numbers, "cs", ["mcs"],
              ["mono", "Source.exe"], [tc1])
    print(out)
    assert 1 == len(out)
    assert '57' == out[0].stdout
    assert Status.OK == out[0].status
Esempio n. 19
0
def is_supported_ruby_version(version):
    '''
    Checks if the version defined in .ruby-version is supported
    '''
    is_supported = 0

    if version:
        logger = get_logger('setup-ruby')

        RUBY_VERSION_MIN = os.getenv('RUBY_VERSION_MIN')

        is_supported = run(
            logger,
            f'ruby -e "exit Gem::Version.new(\'{shlex.split(version)[0]}\') >= Gem::Version.new(\'{RUBY_VERSION_MIN}\') ? 1 : 0"',  # noqa: E501
            cwd=CLONE_DIR_PATH,
            env={},
            ruby=True
        )

        upgrade_msg = 'Please upgrade to an actively supported version, see https://www.ruby-lang.org/en/downloads/branches/ for details.'  # noqa: E501

        if not is_supported:
            logger.error(
                'ERROR: Unsupported ruby version specified in .ruby-version.')
            logger.error(upgrade_msg)

        if version == RUBY_VERSION_MIN:
            logger.warning(
                f'WARNING: Ruby {RUBY_VERSION_MIN} will soon reach end-of-life, at which point Federalist will no longer support it.')  # noqa: E501
            logger.warning(upgrade_msg)

    return is_supported
def scrape(arr):
    dispFilter = get_dispensary_filter(arr)
    leafbuyer_scraper = LeafbuyerDispensaryScraper(
        HttpClient(), LeafbuyerDispInfoExtractor())
    result = run(dispFilter.get_state_names(), leafbuyer_scraper.produce,
                 leafbuyer_scraper.consume)
    return json.dumps(result)
Esempio n. 21
0
    def insert(self):
        for i in range(0, 3):
            try:
                print "[ +D+ ] - Attempting to trace %s" % self.s_name
                logfile = runner.run(self.d_path, self.t_path, self.t_args, self.s_path, self.w_time, self.m_time)

                if logfile is not None:
                    trace_data = {
                        'seed_name': self.s_name,
                        'data': logfile
                    }

                    trace = packer.pack(trace_data)
                    # Set long TTR as trace processing may take a while
                    self.bs.use(self.trace_results)
                    self.bs.put(trace, ttr=600)
                    self.job.delete()
                    break
                else:
                    print "[ +E+ ] - Error retrieving log file. Restarting."

            except:
                print "[ +D+ ] - Something went wrong. Restarting."

        else:
            print "[ +E+ ] - Reached max tries.  Burying."
            self.job.bury()
Esempio n. 22
0
    def insert(self):
        for i in range(0, 3):
            try:
                print "[ +D+ ] - Attempting to trace %s" % self.s_name
                logfile = runner.run(self.d_path, self.t_path, self.t_args,
                                     self.s_path, self.w_time, self.m_time)

                if logfile is not None:
                    trace_data = {'seed_name': self.s_name, 'data': logfile}

                    trace = packer.pack(trace_data)
                    # Set long TTR as trace processing may take a while
                    self.bs.use(self.trace_results)
                    self.bs.put(trace, ttr=600)
                    self.job.delete()
                    break
                else:
                    print "[ +E+ ] - Error retrieving log file. Restarting."

            except:
                print "[ +D+ ] - Something went wrong. Restarting."

        else:
            print "[ +E+ ] - Reached max tries.  Burying."
            self.job.bury()
Esempio n. 23
0
 def test_signal(self):
     if sys.platform == 'win32':
         py.test.skip("no death by signal on windows")
     res = runner.run(
         [sys.executable, "-c", "import os; os.kill(os.getpid(), 9)"], '.',
         py.path.local(self.fn))
     assert res == -9
Esempio n. 24
0
def _get_output(network_config):
    state_flag = _create_state_flag(network_config)

    # Get ips
    return yaml.load(
        runner.run(['terraform', 'output', '-json'] + state_flag,
                   capture_stdout=True))
Esempio n. 25
0
def Test_Main(Debug, CurrentTestSet, CurrentTSTest, CurrentRun):
  try :
    # clear output window
    TDOutput.Clear()

    # TODO: put your code here
    import sys, os
    WORKSPACE = r'C:\Comcast_QA'
    sys.path.insert(0, os.path.join(WORKSPACE, 'spares-test'))

    ALM_OBJECTS = {
        "Debug": Debug,
        "CurrentTestSet": CurrentTestSet,
        "CurrentTSTest": CurrentTSTest,
        "CurrentRun": CurrentRun,
        "TDHelper": TDHelper,
        "TDInput":  TDInput,
        "TDOutput": TDOutput,
        "XTools": XTools
    }

    import runner
    result = runner.run(r'tests\api\advance_search\network_location.txt', **ALM_OBJECTS)

    if not Debug :
      TDOutput.Print("Put your code here")
  # handle errors
  except pythoncom.com_error, (hr, desc, exc, arg):
    TDOutput.Print("Run-time error %d: %s" % (hr, desc))
    # update execution status in "Test" mode
    if not Debug :
      CurrentRun.Status = "Failed"
      CurrentTSTest.Status = "Failed"
Esempio n. 26
0
def main() -> None:
    args = parse_args()
    if args.filename == '-':
        prog_text = sys.stdin.read()
    else:
        with open(args.filename) as f:
            prog_text = f.read()

    env = bytecode.EvalEnv(
        optimize_tail_calls=args.tail_calls,
        jit=args.jit,
        bytecode_jit=args.bytecode_jit,
        print_specializations=args.print_specializations,
        print_optimizations=args.print_optimizations,
        inline_threshold=args.inline_count,
        specialization_threshold=args.specialize_count,
    )
    start = time.perf_counter()
    runner.add_intrinsics(env)
    runner.add_builtins(env)
    runner.add_prelude(env)
    startup = time.perf_counter()
    print(runner.run(env, prog_text))
    end = time.perf_counter()
    env.stats.startup_time = startup - start
    env.stats.program_time = end - startup
    with Output(args) as out_f:
        args.out_file = out_f.file
        if args.machine_readable:
            report_stats_json(args, env)
        else:
            report_stats(args, env)
Esempio n. 27
0
def test_c_add_two_numbers_code_compile_error():
    out = run(c_source_code_add_two_numbers_compile_error, "c",
              ["gcc", "-o", "program"], ["./program"], [tc1])
    assert 1 == len(out)
    assert ": error: expected" in out[0].stderr
    assert "sum = a  b;" in out[0].stderr
    assert Status.COMPILE_ERROR == out[0].status
Esempio n. 28
0
def test_run_os_failure(mock_popen):
    mock_logger = Mock()
    command = 'foobar'

    mock_popen.side_effect = OSError('ugh')

    result = run(mock_logger, command)

    mock_popen.assert_called_once_with(shlex.split(command),
                                       cwd=None,
                                       env=None,
                                       shell=False,
                                       executable=None,
                                       stderr=subprocess.STDOUT,
                                       stdout=subprocess.PIPE,
                                       bufsize=1,
                                       encoding='utf-8',
                                       text=True,
                                       preexec_fn=setuser)

    mock_logger.error.assert_any_call('Encountered a problem executing `' +
                                      ' '.join(shlex.split(command)) + '`.')
    mock_logger.error.assert_any_call('ugh')

    assert result == 1
Esempio n. 29
0
def main():
    # notify('Test', body='Is this thing on?', icon='dialog-question', urgency='LOW')
    with open(SPOOL_FILE, 'r+') as spool_file:
        try:
            fcntl.flock(spool_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
        except BlockingIOError as e:
            print('Sched is already running – exiting…')
            return 2

        spool = yaml.safe_load(spool_file)

        run_result = run(spool)

        print(run_result)

        if not run_result['did_something']:
            # no need to write that file every minute
            return 0
        else:
            spool_file.seek(0)
            yaml.dump({'jobs': run_result['jobs']},
                      spool_file,
                      default_flow_style=False)
            spool_file.truncate()

        if run_result['has_errors']:
            return 1
Esempio n. 30
0
def test_run(mock_popen):
    mock_logger = Mock()
    command = 'foobar'

    mock_popen.return_value = Mock(
        returncode=0, stdout=Mock(readline=Mock(return_value='foobar')))

    result = run(mock_logger, command)

    mock_popen.assert_called_once_with(
        shlex.split(command),
        cwd=None,
        env=None,
        shell=False,
        executable=None,
        stderr=subprocess.STDOUT,
        stdout=subprocess.PIPE,
        bufsize=1,
        encoding='utf-8',
        text=True,
        preexec_fn=setuser,
    )

    mock_logger.info.assert_called_once_with('foobar')

    assert result == 0
Esempio n. 31
0
def get_reco():

    data = [
        concentration,
        year_entry,
        sem_entry,
        course1,
        int(difficulty1),
        int(teaching1),
        int(material1),
        course2,
        int(difficulty2),
        int(teaching2),
        int(material2),
        course3,
        int(difficulty3),
        int(teaching3),
        int(material3),
        course4,
        int(difficulty4),
        int(teaching4),
        int(material4),
        int(nextdifficulty),
        int(nextteaching),
        int(nextmaterial),
    ]

    courses = runner.run(data)

    fifth_window(courses)
Esempio n. 32
0
    def _run_task(self, pattern, task, host_list=None, conditional=False):
        '''

        '''
        if host_list is None:
            host_list = self.host_list

        instructions = task['do']
        (comment, module_details) = instructions
        (module_name, module_args) = module_details

        namestr = "%s/%s" % (pattern, comment)

        if conditional:
            namestr = "subset/%s" % namestr
        print "TASK [%s]" % namestr

        runner = self._get_task_runner(
            pattern=pattern,
            host_list=host_list,
            module_name=module_name,
            module_args=module_args,
        )

        results = runner.run()
Esempio n. 33
0
 def runp(cmd):
     return run(logger,
                cmd,
                cwd=CLONE_DIR_PATH,
                env={},
                check=True,
                node=True)
Esempio n. 34
0
 def testRunner( self ):
     co = functionTouchFile.__code__
     ret = runner.run( co )
     try:
         with open( 'test.test', 'r'):
             pass
     except IOError:
         self.assertTrue( False, 'Code object file not made.' )
Esempio n. 35
0
 def _run_lola(self, lola_file_name, formula):
     """
     Run LoLA for a certain file and formula
     """
     LOG.info("Running LoLA in temporal file for formula:")
     LOG.info("'{0}'".format(formula))
     command = ["lola", lola_file_name, "--formula={0}".format(formula)]
     (ret, _, stderr) = run(command)
     return check_result(stderr)
Esempio n. 36
0
def main(args=None):
    if args is None:
        args = sys.argv[1:]

    # Initialize colors
    init()

    # Highlight subprocess output
    if args and args[0] != '--':
        run(args, postprocessor=highlight_traceback_lines)
        return

    # Highlight from args or stdin
    if args:
        s = ' '.join(args[1:])
    else:
        s = sys.stdin.read()
    print('\n'.join(highlight_tracebacks(s)))
Esempio n. 37
0
def main():
    hardware = Hardware()
    state = State()
    runner.run(hardware, state)
Esempio n. 38
0
        sock.sendall(identity)
        sock.sendall("request.")
        config_file = sock.recv(4)

        #No files remaining, time to finish
        if config_file == "wait":
            print "All remaining config files are in progress. Sleeping."
            sleep(timeout)
            print "Waking up."
        
        elif config_file == "done":
            print "All config files complete. Shutting down."
            done = True

        #A new file has been sent. Copy it locally, then run it.
        else:
            config_file = sock.recv(int(config_file)) #Get the name of the file
            print "Running config file: " + config_file
            f = open(config_file,"w")
            data = sock.recv(8) #Get the data
            data = sock.recv(int(data))
            f.write(data)
            f.close()
            sock.close()
            runner.run(config_file, HOST, True, identity) #Run it
            os.remove(config_file) #Clean up
            sock = socket.socket()
            sock.connect((HOST,PORT))
            sock.sendall(identity)
            sock.send("complete") #We finished the file, tell the server
Esempio n. 39
0
 def test_timeout_syscall(self):
     res = runner.run([sys.executable, "-c", "import socket; s=s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM); s.bind(('', 0)); s.recv(1000)"], '.', py.path.local(self.fn), timeout=3)
     assert res == -999        
Esempio n. 40
0
 def test_timeout_success(self):
     res = runner.run([sys.executable, "-c", "print 42"], '.',
                      py.path.local(self.fn), timeout=2)
     assert res == 0
     out = py.path.local(self.fn).read('r')
     assert out == "42\n"        
Esempio n. 41
0
 def test_timeout(self):
     res = runner.run([sys.executable, "-c", "while True: pass"], '.', py.path.local(self.fn), timeout=3)
     assert res == -999
Esempio n. 42
0
 def test_timeout_lock(self):
     res = runner.run([sys.executable, "-c", "import threading; l=threading.Lock(); l.acquire(); l.acquire()"], '.', py.path.local(self.fn), timeout=3)
     assert res == -999
Esempio n. 43
0
 def test_error(self):
     res = runner.run([sys.executable, "-c", "import sys; sys.exit(3)"], '.', py.path.local(self.fn))
     assert res == 3
Esempio n. 44
0
 def test_timeout_success(self, out):
     res = runner.run([sys.executable, "-c", "print 42"], '.',
                      out, timeout=2)
     assert res == 0
     out = out.read()
     assert out == "42\n"        
Esempio n. 45
0
for (benchmark, input_size) in benchmarks.items():
  print >> sys.stderr, 'Benchmark:', benchmark
  
  runner.build(benchmark, 'gcc')
  
  output_file = OUTPUT_DIR + '/' + benchmark + '.log'
  
  # Run once to ensure inputs are unpacked
  # Not required, now that everything is ready
  #runner.run(benchmark=benchmark, config='gcc', coz=False, runs=1, size=input_size)
  
  print >> sys.stderr, 'Starting clean runs'
  times = runner.run(benchmark=benchmark,
                     config='gcc',
                     size=input_size,
                     runs=RUNS,
                     coz=False,
                     keep_inputs=True)
  for t in times:
    print >> results, ','.join([benchmark, 'clean', str(t)])
  results.flush()
  
  # Remove the output file
  if os.path.isfile(output_file):
    os.remove(output_file)
  
  print >> sys.stderr, 'Starting zero delay runs'
  times = runner.run(benchmark=benchmark,
                     config='gcc',
                     runs=RUNS,
                     size=input_size,
from sleep import sleep
import runner


def task(name):
    print(name, 1)
    yield sleep(1)
    print(name, 2)
    yield sleep(2)
    print(name, 3)

if __name__ == '__main__':
    runner.run((task('hsfzxjy'), task('Jack')))
Esempio n. 47
0
table = {}
def fib(n):
    global table
    if n in [1, 2]:
        return 1
    if n in table:
        return table[n]
    value = fib(n-2) + fib(n-1)
    table[n] = value
    return value

def fib_fast(n):
    if n in [1, 2]:
        return 1
    a, b = 1, 1
    while (b < n):
        a, b = b, a+b
    return b

N = 35

r.run(fib_fast, N)
r.run(fib, N)
r.run(fib_slow, N)





Esempio n. 48
0
 def test_run(self, out):
     res = runner.run([sys.executable, "-c", "print 42"], '.', out)
     assert res == 0
     assert out.read() == "42\n"
Esempio n. 49
0
 def test_error(self, out):
     res = runner.run([sys.executable, "-c", "import sys; sys.exit(3)"], '.', out)
     assert res == 3
Esempio n. 50
0
#!/usr/bin/env python
import os
import sys

# Force our parent directory (the `pyrun` package) into python path:
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

from runner import run

# --------------------------------------------------
if __name__ == "__main__":
    print("########################")
    print("Running a script...\n")
    run(package='scripts/hello', function='run', path_extras=["scripts"], verbose=True)

    print("\n########################")
    print("Calling a model method...\n")
    run(package='models/hello', model='Hello', method='hi', verbose=True)

    print("\n########################")
    print("Done.")

Esempio n. 51
0
 def test_signal(self):
     if sys.platform == 'win32':
         py.test.skip("no death by signal on windows")
     res = runner.run([sys.executable, "-c", "import os; os.kill(os.getpid(), 9)"], '.', py.path.local(self.fn))
     assert res == -9
Esempio n. 52
0
from runner import run

s = '''
a
    a1
    a_done.signal()
    b_done.wait()
    a2

b
    b1
    b_done.signal()
    a_done.wait()
    b2

a_done = Semaphore(0)
b_done = Semaphore(0)
'''

r = run(s)#.show(pause=True)
#print len(r)
assert all(r('a1 < b2'))
assert all(r('b1 < a2'))
assert any(r('a1 < b1'))
assert any(r('a1 > b1'))
assert any(r('a2 < b2'))
assert any(r('a2 > b2'))
Esempio n. 53
0
 def test_timeout(self, out):
     res = runner.run([sys.executable, "-c", "while True: pass"], '.', out, timeout=3)
     assert res == -999
Esempio n. 54
0
    def test_knn_state(self):
        train = pure_multivariate_signal( 40, 3 )
        test = pure_multivariate_signal( 20, 3 )

        clf = kNN(k=10)
        clf.train(train)

        clf.ca.enable(['estimates', 'predictions', 'distances'])

        p = clf.predict(test.samples)

        self.assertTrue(p == clf.ca.predictions)
        self.assertTrue(len(clf.ca.estimates) == 80)
        self.assertTrue(set(clf.ca.estimates[0].keys()) == set(test.targets))
        self.assertTrue(clf.ca.distances.shape == (80,160))

        self.assertTrue(not clf.ca.distances.fa is train.sa)
        # Those are deep-copied now by default so they should not be the same
        self.assertTrue(not (clf.ca.distances.fa['chunks'] is train.sa['chunks']))
        self.assertTrue(not (clf.ca.distances.fa.chunks is train.sa.chunks))

def suite():  # pragma: no cover
    return unittest.makeSuite(KNNTests)


if __name__ == '__main__':  # pragma: no cover
    import runner
    runner.run()

Esempio n. 55
0
from runner import run


if __name__ == '__main__':
    run()