This function overrides error output. All errors are displayed.

@inheritdoc
328823
public function render ($content = null)
		{
			// Custom error output.
			$errors = $this->model->getErrors($this->attribute);

			if (count($errors) == 0)
				$this->parts[ '{error}' ] = '';
			else
			{
				$class = isset($this->errorOptions[ 'class' ]) ? ' class="' . $this->errorOptions[ 'class' ] . '"' : '';
				$this->parts[ '{error}' ] = '<div' . $class . '><ul class="list-unstyled">';
				foreach ($errors as $e)
				{
					$this->parts[ '{error}' ] .= '<li>' . $e . '</li>';
				}
				$this->parts[ '{error}' ] .= '</ul></div>';
			}

			return parent::render($content);
		}
469579
private void printErrors(final List<String> filteredDoc,
      final List<String> filteredRefs, final List<String> filteredPreds) {
    this.printStream.println("Errors: {");
    this.printStream.println("Tok: Ref | Pred");
    this.printStream.println("---------------");
    for (int i = 0; i < filteredDoc.size(); i++) {
      this.printStream.println(filteredDoc.get(i) + ": " + filteredRefs.get(i)
          + " | " + filteredPreds.get(i));
    }
    this.printStream.println("}\n");
  }
701602
protected function onError() {
        global $OUTPUT;

        $message = $this->message;
        if ($this->debugMode && !empty($this->reason)) {
            $message = $this->reason;
        }

        // Display the error message from the provider's side if the consumer has not specified a URL to pass the error to.
        if (empty($this->returnUrl)) {
            $this->errorOutput = $OUTPUT->notification(get_string('failedrequest', 'enrol_lti', ['reason' => $message]), 'error');
        }
    }
106468
function printErrors( summary, errors ) {
  print( chalk.red( summary ));
  errors.forEach( err => print( err.message || err ));
}
193265
public function output_error($code)
    {
        // Output the proper response code.
        if (array_key_exists((int) $code, $this->errors)) {
            http_response_code((int) $code);
        }

        $payload = array(
            'status' => 'error',
            'version' => $this->version,
            'data' => array(
                'code' => $code,
                'message' => $this->errors[$code]
            ),
            'runtime' => round(microtime(true) - $this->runtime, 3)
        );

        // Output the data in the desired format.
        switch ($this->format) {
            case 'xml':
                return output_pretty_xml($payload);
            case 'json':
                return output_pretty_json($payload);
            case 'jsonp':
                return output_pretty_jsonp($payload, $this->callback);
            case 'php':
                return output_pretty_php($payload);
        }

        return false;
    }
592354
public function error()
    {
        if (!$this->output) { return $this; }

        foreach (func_get_args() as $line) {

            if (is_array($line)) {
                call_user_func_array([ $this->output, 'write' ], $line);
                continue;
            }

            $this->output->getErrorOutput()->write($line);
        };

        return $this;
    }
255470
protected function error($message)
    {
        if ($this->output instanceof ConsoleOutputInterface) {
            $this->output->getErrorOutput()->writeln("<error>$message</error>");
        } else {
            $this->output->writeln("<error>$message</error>");
        }
    }
413943
protected function _errorhandler_output($errstr, $backtrace, $errortype) {
		// output error
		$error = '<div class="dp_container">';
		$error .= '<div class="skyline">'.$errortype.'</div>';
		$error .= '<h1 class="exception">'.htmlspecialchars($errstr, ENT_QUOTES, 'UTF-8').'</h1>';

		$count = 0;
		foreach ($backtrace as $key => $value) {
			// only if file is available
			if (!empty($value['file']) && is_file($value['file'])) {
				$id_file = '_errorhandler_file_'.$this->errorcounter.'_'.$count;
				$id_args = 'errorhandler_args_'.$this->errorcounter.'_'.$count;
				$show = ($count === 0) ? 'style="display: block;"' : '';

				if ($count>0) {
					$call = $value['class'].$value['type'].$value['function'].'()';
					$error .= '<h2>'.$call.'</h2>';
				}

				// highlight the file name
				$file = preg_replace('=[^/]+$=', '<strong>$0</strong>', $value['file']);
				
				$error .= '<h3>'.$file.' (Line '.$value['line'].')</h3>';
				$error .= '<div class="file" id="'.$id_file.'" '.$show.'>'.$this->_getContent($value['file'], $value['line']).'<div style="clear: both;"></div></div>';

				if (count($value['args'])>0 and $count > 0) {
					$dump = htmlspecialchars(print_r($value['args'], true));
					$error .= '<h3>Arguments ('.count($value['args']).')</h3>';
					$error .= '<div class="args" id="'.$id_args.'">'.$dump.'</div>';
				}

				$count++;
			}
		}

		$error .= '</div>';

		// output css and js only at first call
		if ($this->errorcounter === 1) $error .= $this->_debug_styles();

		return $error;
	}
988597
public function outputError($data)
    {
        $defaults = [
            'level' => 0,
            'error' => 0,
            'code' => 0,
            'description' => '',
            'file' => '',
            'line' => 0,
            'context' => [],
            'start' => 2,
        ];
        $data += $defaults;

        $files = static::trace(['start' => $data['start'], 'format' => 'points']);
        $code = '';
        $file = null;
        if (isset($files[0]['file'])) {
            $file = $files[0];
        } elseif (isset($files[1]['file'])) {
            $file = $files[1];
        }
        if ($file) {
            $code = static::excerpt($file['file'], $file['line'], 1);
        }
        $trace = static::trace(['start' => $data['start'], 'depth' => '20']);
        $insertOpts = ['before' => '{:', 'after' => '}'];
        $context = [];
        $links = [];
        $info = '';

        foreach ((array)$data['context'] as $var => $value) {
            $context[] = "\${$var} = " . static::exportVar($value, 3);
        }

        switch ($this->_outputFormat) {
            case false:
                $this->_data[] = compact('context', 'trace') + $data;

                return;
            case 'log':
                static::log(compact('context', 'trace') + $data);

                return;
        }

        $data['trace'] = $trace;
        $data['id'] = 'cakeErr' . uniqid();
        $tpl = $this->_templates[$this->_outputFormat] + $this->_templates['base'];

        if (isset($tpl['links'])) {
            foreach ($tpl['links'] as $key => $val) {
                $links[$key] = Text::insert($val, $data, $insertOpts);
            }
        }

        if (!empty($tpl['escapeContext'])) {
            $context = h($context);
            $data['description'] = h($data['description']);
        }

        $infoData = compact('code', 'context', 'trace');
        foreach ($infoData as $key => $value) {
            if (empty($value) || !isset($tpl[$key])) {
                continue;
            }
            if (is_array($value)) {
                $value = implode("\n", $value);
            }
            $info .= Text::insert($tpl[$key], [$key => $value] + $data, $insertOpts);
        }
        $links = implode(' ', $links);

        if (isset($tpl['callback']) && is_callable($tpl['callback'])) {
            call_user_func($tpl['callback'], $data, compact('links', 'info'));

            return;
        }
        echo Text::insert($tpl['error'], compact('links', 'info') + $data, $insertOpts);
    }
997705
protected function writeErrorAndDie(array $errors)
    {
        $output = (new ConsoleOutput)->getErrorOutput();

        foreach ($errors as $error) {
            $output->writeln($error);
        }

        die(1);
    }
371606
protected function writeError(OutputInterface $output, $error)
    {
        $result = [trim($error->getMessage())];

        // If the output is verbose, add file and location
        if ($output->isVerbose()) {
            $file = $error->getFile();
            if ($file) {
                $result[] = "File: {$file}" . ($error->getLine() ? ':' . $error->getLine() : '');
            }
        }

        // If the output is very verbose, add stacktrace
        if ($output->isVeryVerbose()) {
            $trace = $error->getTraceAsString();
            $result[] = 'Trace:';
            $result[] = $trace;
        }

        $this->output->error($result);
    }
599841
public function displayErrors($htmlOutput = true){

        $returnValue = (string) '';

        foreach($this->errors as $error){
            $returnValue .= $error['message'];
            if(isset($error['file']) && isset($error['line'])){
                $returnValue .= ' in file '.$error['file'].', line '.$error['line'];
            }
            $returnValue .= PHP_EOL;
        }

        if($htmlOutput){
            $returnValue = nl2br($returnValue);
        }

        return (string) $returnValue;
    }
1236137
def display_messages
      [:errors, :warnings].each do |type|
        send(type).each do |msg|
          output.puts(msg.to_s)
        end
      end
    end
793405
public static function forError(): OutputStream
    {
        if (null === self::$err) {
            self::$err = self::create('php://stderr');
        }

        return self::$err;
    }
262006
private function displayBatchesErrorFile($batchesError)
    {
        $output = [];
        foreach ($batchesError as $key => $batch) {
            $errors = $this->synchronizer->getJobJsonError($batch['JobID']);
            array_push($output, '<error><pre>'.print_r($errors).'</pre></error>');
        }

        return $output;
    }
697994
protected static function printMessageFail(
        OutputInterface $output,
        $header,
        $body
    ) {
        self::printStructureMessage(
            $output,
            $header,
            $body,
            'fail'
        );
    }
1048344
protected function log_error($errors) {
        if (empty($errors)) {
            return;
        }

        foreach ($errors as $code => $langstring) {
            if (!isset($this->errors[$this->linenb])) {
                $this->errors[$this->linenb] = array();
            }
            $this->errors[$this->linenb][$code] = $langstring;
        }
    }