Log all errors.
@param {Array} array of errors
@param {Boolean} throwsErrors (default false)
@return {Boolean} True if there were no error, false otherwise.
176443
function (errors, throwsErrors) {
                if (errors.length === 0) {
                    return true;
                }
                if (!throwsErrors) {
                    for (var i = 0; i < errors.length; i++) {
                        this.$logError(errors[i].msgId, errors[i].msgArgs);
                    }
                } else {
                    var error, logs = aria.core.Log;
                    // aria.core.Log may not be available
                    if (logs) {
                        var messages = [];
                        for (var i = 0; i < errors.length; i++) {
                            errors[i].message = logs.prepareLoggedMessage(errors[i].msgId, errors[i].msgArgs);
                            messages.push(errors[i].message);
                        }
                        error = new Error(messages.join('\n'));
                    } else {
                        error = new Error();
                    }
                    error.errors = errors;
                    throw error;
                }
                return false;
            }
1292787
@Override
    public List<Object> checkForErrors(Object[] objs) {
        List<Object> errors = new ArrayList<Object>();
        if (objs != null) {
            for (int cont = 0; cont < objs.length; cont ++) {
                if (objs[cont] == null) {
                    logger.debug("A operation could not be performed.");
                    errors.add(objs[cont]);
                }
            }
        }
        return errors;
    }
182493
function errorHandler(response) {
        if (response) {
          var errorData = _buildError(xhr, url, method, response);
          Logger.error(errorData);

          if (errorCallback) {
            Logger.warnCallbackDeprecation();
            errorCallback(errorData);
          }
          reject(errorData);
        }
      }
833962
function expandErrors(logger) {
    var oldLogFunc = logger.log
    logger.log = function() {
      var args = Array.prototype.slice.call(arguments, 0)
      if (args.length >= 2 && args[1] instanceof Error) {
        args[1] = args[1].stack
      }
      return oldLogFunc.apply(this, args)
    };
    return logger
  }
1224785
def log_errors(self):
        
        for result in self._stored.values():
            failure = result.original_failure()
            if failure is not None:
                log.err(failure, "Unhandled error in stashed EventualResult:")
901536
function onError(error) {
    me.terminated = true;
    if (me.terminating && me.terminationHandler) {
      me.terminationHandler(me);
    }
    me.terminating = false;

    for (var id in me.processing) {
      if (me.processing[id] !== undefined) {
        me.processing[id].resolver.reject(error);
      }
    }
    me.processing = Object.create(null);
  }
1240152
public boolean hasFatalErrors() {
        for (final TopicErrorDatabase.ErrorType type : errorTypes) {
            if (TopicErrorDatabase.FATAL_ERROR_TYPES.contains(type)) {
                return true;
            }
        }

        return false;
    }
977732
function printErrors(summary, errors) {
  logError(`${summary}\n`);

  errors.forEach(err => {
    logError(`\t- ${err.message || err}`);
  });

  console.log();
}
1344163
function error (message) {
  console.log(chalk.bgRed.white('[Error]' + message))
  throw new Error(message)
}
410420
public boolean hasErrors() {
        if (!errors.isEmpty())
            return true;

        for (PathWrapper ar : pathWrappers) {
            if (ar.hasErrors())
                return true;
        }

        return false;
    }
246524
public function addErrors(array $errors)
    {
        foreach ($errors as $code => $message) {
            $this->addError($code, $message);
        }
    }
32061
function (error) {
        if (!this.started) {
            return;
        }

        var errorHandlers = this.errorHandlers,
            length = errorHandlers.length,
            errorHandler,
            errorHandled = false,
            errorString,
            i;

        //Exit handling
        if (error instanceof SystemExit) {
            this._exit(error.code);
            return;
        }

        try {
            for (i = 0; i < length; i += 1) {
                errorHandler = errorHandlers[i];
                errorHandled = !!errorHandler(error);

                if (errorHandled) {
                    return;
                }
            }
        } catch (e) {
            this._printError(e);
            this._exit(1);
        }

        //Default error handling
        errorString = '' + (error.stack || error);
        this._printError(errorString);
        this._exit(1);
    }
758078
@Override
	public void registerErrorHandlers(ErrorHandler... handlers) {
		if (handlers != null) {
			for (ErrorHandler handler : handlers) {
				this.registerErrorHandler(handler);
			}
		}
	}
800693
function resetErrors() {

            errors = [];
            window.Validation.hasScrolled = false;

            node.find('[' + _data.errorList + ']').remove();
            node.find('.' + options.submit.settings.errorClass).removeClass(options.submit.settings.errorClass);

        }
638381
function(error) {
		if (this.resolved) {
			throw new Error('Future resolved more than once');
		} else if (!error) {
			throw new Error('Must throw non-empty error');
		}
		this.error = error;
		this.resolved = true;

		var callbacks = this.callbacks;
		if (callbacks) {
			delete this.callbacks;
			for (var ii = 0; ii < callbacks.length; ++ii) {
				try {
					var ref = callbacks[ii];
					if (ref[1]) {
						ref[0].throw(error);
					} else {
						ref[0](error);
					}
				} catch(ex) {
					// console.log('Resolve cb threw', String(ex.stack || ex.message || ex));
					process.nextTick(function() {
						throw(ex);
					});
				}
			}
		}
	}
953760
function(errors, options) {
      errors = v.pruneEmptyErrors(errors, options);
      errors = v.expandMultipleErrors(errors, options);
      errors = v.convertErrorMessages(errors, options);

      var format = options.format || "grouped";

      if (typeof v.formatters[format] === 'function') {
        errors = v.formatters[format](errors);
      } else {
        throw new Error(v.format("Unknown format %{format}", options));
      }

      return v.isEmpty(errors) ? undefined : errors;
    }
365384
function writeLogs(customMethods) {

	// Error level logging with a message but no error
	console.error('Testing ERROR LEVEL without actual error')
	
	// Error level logging with an error but no message
	// This shows enhanced error parsing in logging 
	console.error(new Error("some error"));

	// Error level logging with both message and error
	// This shows enhanced error parsing in logging 
	console.error('Testing ERROR LEVEL with an error', new Error("some error"));
	
	// Warn level logging
	console.warn('Testing WARN LEVEL');

	// Info level logging
	console.info('Testing INFO LEVEL');

	// Log/Debug level logging
	console.log('Testing LOG LEVEL');	
	
	if(customMethods) {
		// Log/Debug level loggin using "debug" alias (not standard but clearer)
		console.debug('Testing DEBUG (AKA LOG) LEVEL');
		
		// Verbose level logging (new level added to go beyond DEBUG)
		console.verbose('Testing TRACE LEVEL');	
	}
}