Add an error test to the suite.
760536
def _add_error(self, message):
        """"""
        error_line = Result(False, None, message, Directive(""))
        self._suite.addTest(Adapter(self._filename, error_line))
994984
def prepare_suite(self, suite):
        """"""
        all_tests = {}
        for s in suite:
            m = re.match(r'(\w+)\s+\(.+\)', str(s))
            if m:
                name = m.group(1)
            else:
                name = str(s).split('.')[-1]
            all_tests[name] = s

        return self.orderTests(all_tests, suite)
736060
def _set_add_options(cls, checked_codes, options):
        """"""
        checked_codes |= cls._expand_error_codes(options.add_select)
        checked_codes -= cls._expand_error_codes(options.add_ignore)
1244773
public void addError(ValidationError error) {
        if (CollectionUtil.isEmpty(errors)) {
            errors = CollectionUtil.createArrayList(Const.INITIAL_CAPACITY);
        }
        errors.add(error);
    }
1103275
def add_error(self, error):
        
        if is_non_string_iterable(error) and not isinstance(error, collections.Mapping):
            for value in error:
                self.add_error(value)
        else:
            self.append(error)
1056461
def run_setup_error_group():
  
  test = htf.Test(htf.PhaseGroup(
      setup=[error_setup_phase],
      main=[main_phase],
      teardown=[teardown_phase],
  ))
  test.execute()
324771
def finish_suite(suite)
      total      = suite.count_tests
      passes     = suite.count_passes
      assertions = suite.count_assertions
      failures   = suite.count_failures
      errors     = suite.count_errors
      skips      = suite.count_skips

      bar = '=' * 78
      # @FIXME: Remove this, since Colorize already take care of colorize?
      if colorize?
        bar = if pass == total then Colorize.green(bar)
              else Colorize.red(bar) end
      end

      # @FIXME: Should we add suite.runtime, instead if this lame time calculations?
      tally = [total, assertions, (Time.new - @time)]

      io.puts bar
      io.puts "  pass: %d,  fail: %d,  error: %d, skip: %d" % [passes, failures, errors, skips]
      io.puts "  total: %d tests with %d assertions in %f seconds" % tally
      io.puts bar
    end
851304
def add_scan_error(self, scan_id, host='', name='', value='', port=''):
        
        self.scan_collection.add_result(scan_id, ResultType.ERROR, host, name,
                                        value, port)
559012
def add(self, error):
        
        if not self._path_of_(error):
            self.errors.append(error)
            self.errors.sort()
        else:
            super(ErrorTree, self).add(error)
1318067
def add_alignment_errors(self,ae):
    """"""
    self._target_context_errors = None
    self._query_context_errors = None
    self._alignment_errors.append(ae)
    self._general_errors.add_alignment_errors(ae)
1347266
def finish_suite(suite)
      total      = colorize_count("%d tests", suite.count_tests, :bold)
      passes     = colorize_count("%d passed", suite.count_passes, :pass)
      assertions = colorize_count("%d assertions", suite.count_assertions, nil)
      failures   = colorize_count("%d failures", suite.count_failures, :fail)
      errors     = colorize_count("%d errors", suite.count_errors, :error)
      skips      = colorize_count("%d skips", suite.count_skips, :skip)

      io.puts "Finished in %.6f seconds." % (Time.now - @time)
      io.puts

      io.puts [ total, passes, failures, errors, skips, assertions ].join(", ")

      # Please keep this newline, since it will be useful when after test case
      # there will be other lines. For example "rake aborted!" or kind of.
      io.puts
    end
225408
def add_errback(future, callback, loop=None):
    ''''''
    def _error_back(fut):
        if fut._exception:
            callback(fut.exception())
        elif fut.cancelled():
            callback(CancelledError())

    future = ensure_future(future, loop=None)
    future.add_done_callback(_error_back)
    return future
153784
public function addError(Test $test, \Throwable $t, float $time): void
    {
        $this->doAddFault($test, $t, $time, 'error');
        $this->testSuiteErrors[$this->testSuiteLevel]++;
    }
310432
public function addFailure(Test $test, AssertionFailedError $error, float $time): void
    {
        $this->writeCase(
            self::STATUS_FAIL,
            $time,
            $this->getStackTrace($error),
            TestFailure::exceptionToString($error),
            $test
        );

        $this->currentTestPass = false;
    }
1032811
def add_error(self, group, term, sub_term, value):
        """"""

        self._errors[(group, term, sub_term)] = value
140476
def assert_error(text, check, n=1):
    """"""
    assert_error.description = "No {} error for '{}'".format(check, text)
    assert(check in [error[0] for error in lint(text)])
1040002
def error(self, err=None):
        """"""
        if self.state == 'half-open':
            self.test_fail_count = min(self.test_fail_count + 1, 16)
        self.errors.append(self.clock())
        if len(self.errors) > self.maxfail:
            time = self.clock() - self.errors.pop(0)
            if time < self.time_unit:
                if time == 0:
                    time = 0.0001
                self.log.debug('error rate: %f errors per second' % (
                        float(self.maxfail) / time))
                self.open(err)