1. Fill form.
        2. Run scenario.
        3. Delay.
976448
def _run_automation(self, conf):
        
        self._fill_form(self._find_form(conf))
        self._run_scenario(conf)
        self._delay(conf)
1029794
def run_step(self, context):
        
        logger.debug("starting")
        # the in params should be added to context before step execution.
        self.set_step_input_context(context)

        if self.while_decorator:
            self.while_decorator.while_loop(context,
                                            self.run_foreach_or_conditional)
        else:
            self.run_foreach_or_conditional(context)

        logger.debug("done")
1356212
def before_scenario(context, scenario):
    """"""

    # Prepare a new temporary directory.
    context.directory = testfixtures.TempDirectory(create=True)
    context.old_cwd = os.getcwd()
    context.new_cwd = context.directory.path

    # Move into our new working directory.
    os.chdir(context.new_cwd)
244360
def insert(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.insert_key, n, interval)
        self.delay(post_dl)
333172
void waitRun(long waitMillis, int waitNanos, boolean cancelOnTimeOut) {
        if (!mDone) {
            synchronized (this) {
                if (!mDone) {
                    try {
                        this.wait(waitMillis, waitNanos);
                    } catch (InterruptedException ignored) {
                    } finally {
                        if (!mDone && cancelOnTimeOut)
                            mDone = true;
                    }
                }
            }
        }
    }
677808
def submit(self, __fun, *args, **kwargs):
    

    future = Future().bind(__fun, *args, **kwargs)
    self.enqueue(future)
    return future
1183700
def submit(self, call, *args, **kwargs):
        
        future = StoredFuture(call, *args, **kwargs)
        self._queue.put(future)
        self._ensure_worker()
        return future
728468
private function fillRunQueue()
    {
        $opts = $this->options;
        while (\count($this->pending) && \count($this->running) < $opts->processes) {
            $tokenData = $this->getNextAvailableToken();
            if ($tokenData !== false) {
                $this->acquireToken($tokenData['token']);
                $env = ['TEST_TOKEN' => $tokenData['token'], 'UNIQUE_TEST_TOKEN' => $tokenData['unique']] + Habitat::getAll();
                $this->running[$tokenData['token']] = array_shift($this->pending)->run($opts->phpunit, $opts->filtered, $env, $opts->passthru, $opts->passthruPhp);
                if ($opts->verbose) {
                    $cmd = $this->running[$tokenData['token']];
                    echo "\nExecuting test via: {$cmd->getLastCommand()}\n";
                }
            }
        }
    }
1041618
function delayFile() {
	var stream = fs.createReadStream(file),
	    player = new Cvlc({debug: true});

	console.time('starting_stream');
	player.play(stream, function startedStream() {
		console.timeEnd('starting_stream');

		setTimeout(function() {
			
			Fn.series(function rewind(next) {
				player.cmd('seek 1', next)
			}, function rate(next) {
				console.time('rate3')
				player.cmd('rate 3', function() {
					console.timeEnd('rate3');

					setTimeout(function() {
						player.cmd('rate 1');
					}, 200)

					
				});

				next();
			}, function done() {

			});
		}, 1000);
	});
}
923296
def fill_out_and_submit(self, data, prefix='', turbo=False):
        
        return self.get_elm(tag_name='form').fill_out_and_submit(data, prefix, turbo)
1126442
public function perform()
    {
        $field = $this->option('field', self::FIELD_NAME);
        if (App::instance()->request()->body()->get($field) !== '') {
            $this->reject(I18n::translate('uniform-filled-potty'), $field);
        }
        $this->form->forget($field);
    }
597429
async function run () {
  if (options.help || Object.keys(options).length === 1) {
    showHelp()
    return
  }
  if (!options.name) {
    console.error('You need to input -n, --name argv')
    return
  }
  if (!options.title) {
    options.title = options.name.split('-').join(' ')
  }

  let content = (await fs.readFile(`${__dirname}/example.tpl`)).toString()
  content = content.replace(/@title@/, options.title || '')
    .replace(/@desc@/, options.desc || '')

  await fs.writeFile(`${__dirname}/../docs/examples/${options.name}.html`, content)
  console.info(`${options.name}.html`)

  let list = (await fs.readFile(`${__dirname}/../docs/_includes/example-list.md`)).toString()
  list += `<li><a href="../examples#${options.name}.html">${options.title}</a></li>\n`
  await fs.writeFile(`${__dirname}/../docs/_includes/example-list.md`, list)
}
1070136
def _start(self):
        """"""

        # TODO : make an update method instead

        last_call = 42
        while self._focus:
            sleep(1 / 100)

            mouse = pygame.mouse.get_pos()
            last_value = self.get()
            self.value_px = mouse[0]

            # we do not need to do anything when it the same value
            if self.get() == last_value:
                continue

            if last_call + self.interval / 1000 < time():
                last_call = time()
                self.func(self.get())
1153802
def bind(self, form):
        """"""
        field = self.field(default=self.default, **self.field_kwargs)
        form._fields[self.name] = field.bind(form, self.name, prefix=form._prefix)
253653
def fill_out(self, data, prefix='', turbo=False):
        
        return self.get_elm(tag_name='form').fill_out(data, prefix, turbo)
307765
public function execute() {
    if (count($this->getInputParameters())) {
      if ($this->isSubmitComplete()) {
        $this->formValues = $this->getFormValues();
        $this->run();
      } else {
        $this->renderInputForm();
      }
    } else {
      $this->run();
    }
  }
248040
function wait(times, interval, callback) {
        Delay.setEditorTimeout(editor, function () {
          resize({});

          if (times--) {
            wait(times, interval, callback);
          } else if (callback) {
            callback();
          }
        }, interval);
      }