Implementation of DOMErrorHandler.handleError that
adds copy of error to list for later retrieval.
6553
public boolean handleError(DOMError error) {
        boolean fail = true;
        String severity = null;
        if (error.getSeverity() == DOMError.SEVERITY_WARNING) {
            fail = false;
            severity = "[Warning]";
        } else if (error.getSeverity() == DOMError.SEVERITY_ERROR) {
            severity = "[Error]";
        } else if (error.getSeverity() == DOMError.SEVERITY_FATAL_ERROR) {
            severity = "[Fatal Error]";
        }
        
        System.err.println(severity + ": " + error.getMessage() + "\t");
        System.err.println("Type : " + error.getType() + "\t" + "Related Data: "
                + error.getRelatedData() + "\t" + "Related Exception: "
                + error.getRelatedException() );
        
        return fail;
    }
248882
function commonErrorHandler(err, req, res, next) { // jshint ignore:line

  debug(err);

  // if we got here without an error, it's a 404 case
  if (!err) {
    err = new NotFoundError();
  }

  // here we've got an error, it could be a different one than
  // the one we've constructed, so provide defaults to be safe
  err.message = err.message || 'Internal Server Error';

  res
    .status(err.code || err.statusCode || 500)
    .type('application/json')
    .send(stringify(err));
}
1253347
function yankError(callback) {
  return function (err, results) {
    if (err || (results[0] && results[0].error)) {
      callback(err || results[0]);
    } else {
      callback(null, results.length ? results[0]  : results);
    }
  };
}
918431
@Override
  public void showErrors(final List<EditorError> errors) {
    final Set<String> messages = errors.stream().filter(error -> editorErrorMatches(error))
        .map(error -> error.getMessage()).distinct().collect(Collectors.toSet());

    if (messages.isEmpty()) {
      errorLabel.setText(StringUtils.EMPTY);
      errorLabel.getElement().getStyle().setDisplay(Display.NONE);
      if (contents.getWidget() != null) {
        contents.getWidget().removeStyleName(decoratorStyle.errorInputStyle());
        contents.getWidget().addStyleName(decoratorStyle.validInputStyle());
      }
    } else {
      if (contents.getWidget() != null) {
        contents.getWidget().removeStyleName(decoratorStyle.validInputStyle());
        contents.getWidget().addStyleName(decoratorStyle.errorInputStyle());
        if (focusOnError) {
          setFocus(true);
        }
      }
      final SafeHtmlBuilder sb = new SafeHtmlBuilder();
      messages.forEach(message -> {
        sb.appendEscaped(message);
        sb.appendHtmlConstant("<br />");
      });
      errorLabel.setHTML(sb.toSafeHtml());
      errorLabel.getElement().getStyle().setDisplay(Display.TABLE);
    }
  }
345700
private void handleResponseError(long requestId, Throwable error) {
    ContextualFuture future = futures.remove(requestId);
    if (future != null) {
      future.context.execute(() -> future.completeExceptionally(error));
    }
  }
700013
function RequestError(err, url) {
	VError.call(this, err, 'for url %s', url);
	this.name = RequestError.name;
}
1310337
function handleError(error, ignoreError) {
    appStore.setLoading(false)
    let reason

    if (error.response) {
        reason = handleResponseError(error)
    } else if (error.status >= 200 && error.status < 300) {
        reason = handleServiceError(error)
    } else {
        reason = handleRequestError(error)
    }

    if (ignoreError !== true) {
        appStore.setError(reason)
    }

    return Promise.reject(reason)
}
335140
public Collection<Exception> error(final Object message, final Throwable error) {
        return Lists.reverse(errorHandlers).stream()
                .flatMap(f -> f.apply(message, error).map(Stream::of).orElse(Stream.empty()))
                .collect(Collectors.toList());
    }
657584
function onErrorResumeNext() {
    var nextSources = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        nextSources[_i] = arguments[_i];
    }
    if (nextSources.length === 1 && Object(_util_isArray__WEBPACK_IMPORTED_MODULE_2__["isArray"])(nextSources[0])) {
        nextSources = nextSources[0];
    }
    return function (source) { return source.lift(new OnErrorResumeNextOperator(nextSources)); };
}
315176
function recrawlError(error, options, callback) {

      if (options.currentRetries <= options.retries) {
        onRecrawl(error,options, callback);
      }
      else {
        callback();
      }
  }
573219
private JsonError handleArray(ArrayNode node, OutputStream output) throws IOException {
		logger.debug("Handling {} requests", node.size());
		JsonError result = JsonError.OK;
		output.write('[');
		int errorCount = 0;
		for (int i = 0; i < node.size(); i++) {
			JsonError nodeResult = handleJsonNodeRequest(node.get(i), output);
			if (isError(nodeResult)) {
				result = JsonError.BULK_ERROR;
				errorCount += 1;
			}
			if (i != node.size() - 1) {
				output.write(',');
			}
		}
		output.write(']');
		logger.debug("served {} requests, error {}, result {}", node.size(), errorCount, result);
		// noinspection unchecked
		return result;
	}
922597
function ErroneousError(e, additional) {
    additional = additional || {};
    this.line = e.lineno || e.lineNumber || additional.lineno;
    this.file = e.filename || e.fileName || additional.filename;
    this.msg = e.message || additional.message;
    this.time = e.timestamp || additional.timestamp || Date.now();
    this.type = (this.parseMessage(this.msg) || e.type || e.name).toLowerCase();

    // If it's a DOM node, let's figure out which
    if (e.target) {
      this.target = this.getTargetIdentifier(e.target);

      if (e.target.nodeName) {
        this.type = 'resource';
        if (e.target.href) {
          this.file = e.target.href;
        } else if (e.target.src) {
          this.file = e.target.src;
        }
      }
    }

    // Parse the stack if any
    this.stack = e.stack;
    this.parseStack(e.stack);
  }
619031
def addError(self, test, exception):
        
        result = self._handle_result(
            test, TestCompletionStatus.error, exception=exception)
        self.errors.append(result)
        self._mirror_output = True
1332098
def _defaultErrorHandler(varBinds, **context):
        """"""
        errors = context.get('errors')

        if errors:
            err = errors[-1]
            raise err['error']
1146497
protected void processServerErrorCallback(HttpServletRequest request, HttpServletResponse response, Throwable cause) {
        final RequestServerErrorHandler serverErrorHandler = serverErrorHandlerLocal.get();
        if (serverErrorHandler == null) {
            return;
        }
        try {
            serverErrorHandler.handle(request, response, cause);
        } catch (Throwable handlingEx) {
            final String msg = "Failed to handle '500 Error' by the handler: " + serverErrorHandler;
            if (errorLogging) {
                logger.error(msg, handlingEx);
            } else {
                logger.debug(msg, handlingEx);
            }
        }
    }
725468
@SuppressWarnings("unchecked")
	public void addErrors(String field, List<String> errors) {
		Assert.notNull(field, "field must not be null");
		Assert.notNull(errors, "field must not be null");

		// do not overwrite existing errors
		Map<String, List<String>> errorMap = (Map<String, List<String>>) this.result
				.get(ERRORS_PROPERTY);
		if (errorMap == null) {
			errorMap = new HashMap<>();
			addResultProperty(ERRORS_PROPERTY, errorMap);
		}

		List<String> fieldErrors = errorMap.get(field);
		if (fieldErrors == null) {
			fieldErrors = new ArrayList<>();
			errorMap.put(field, fieldErrors);
		}
		fieldErrors.addAll(errors);

		addResultProperty(SUCCESS_PROPERTY, Boolean.FALSE);
	}
1344891
function errHandler(err, req, res, next) {
  console.log(addTimestamp("Internal error: " + util.inspect(err)));
  console.error(addTimestamp("Internal error: " + util.inspect(err)));
  if (err && err.stack) {
    console.error(err.stack);
  }

  var errorMessage = {
    msg: 'Internal error: ' + util.inspect(err),
    error: util.inspect(err)
  };
  if (res) {
    res.statusCode = 500;
    res.end(JSON.stringify(errorMessage));
  }

  return errorMessage;
}