Retourne les erreurs retournées par l'API.

@return array
544993
public function getErrors()
    {
        if (false === $this->errors) {
            $this->errors = array();
        }

        if (!is_array($this->errors)) {
            $this->errors = array($this->errors);
        }

        return $this->errors;
    }
668385
public function getInvalidOrMissingErrors()
    {
        $all = $this->invalidAttribs + $this->missingAttribs;
        return array_combine(
            array_keys($all),
            array_map(function ($ref) {
                return $ref['error'];
            }, array_values($all))
        );
    }
549222
public function errorInfo()
	{
		return array
		(
			0 => $this->driver->getSQLState(),
			1 => $this->driver->getErrorCode(),
			2 => $this->driver->getLastMessage()
		);
	}
920451
private function privateErrors() : array
    {
        $errors = [];
        if (isset($this->tests)) {
            foreach ($this->tests as $error => $test) {
                if (!$test((array)$this)) {
                    $errors[] = $error;
                }
            }
        }
        return $errors;
    }
1357231
public static function ensureCurlErrorConstants () {
    $defs = array(
      'CURLE_COULDNT_CONNECT' => 7,
      'CURLE_COULDNT_RESOLVE_HOST' => 6,
      'CURLE_HTTP_RETURNED_ERROR' => 22,
      'CURLE_OPERATION_TIMEDOUT' => 28,
      'CURLE_PEER_FAILED_VERIFICATION' => 51,
      'CURLE_SSL_CACERT' => 60,
      'CURLE_SSL_CACERT_BADFILE' => 77,
      'CURLE_SSL_CERTPROBLEM' => 58,
      'CURLE_SSL_CIPHER' => 59,
      'CURLE_SSL_CONNECT_ERROR' => 35,
      'CURLE_SSL_CRL_BADFILE' => 82,
      'CURLE_SSL_ENGINE_INITFAILED' => 66,
      'CURLE_SSL_ENGINE_NOTFOUND' => 53,
      'CURLE_SSL_ENGINE_SETFAILED' => 54,
      'CURLE_SSL_ISSUER_ERROR' => 83,
      'CURLE_SSL_SHUTDOWN_FAILED' => 80,
      'CURLE_UNSUPPORTED_PROTOCOL' => 1,
      'CURLE_URL_MALFORMAT' => 3,
      'CURLE_USE_SSL_FAILED' => 64,
    );

    foreach ($defs as $constName => $errCode) {
      if (!defined($constName)) {
        define($constName, $errCode);
      }
    }
  }
1355187
public function getCommitErrors()
    {
        $errors = array();

        if ($this->_failed_commits) {
            foreach ($this->_failed_commits as $entity) {
                $errors[(string) $entity->getIdentifier()] = array_values($entity->getErrors()->toArray());
            }
        }

        return $errors;
    }
28489
function get_errors( $emask = null ) {
		$errs = array();
		foreach( $this->err_stack as $t => $ids ) {
			if( $emask !== NULL && ( $emask & $t ) == 0 ) {
				// ignore this error
				continue;
			}
			// collect these errors
			foreach( $ids as $id ){
				$Err = PLUGError::get_reference( $t, $id );
				if( is_object($Err) ){
					$errs[] = $Err;
				}
			}
		}
		return $errs;
	}
405426
public function getFormErrors ()
    {
        return array_map(function (FormValidator $formValidator) {
            return $formValidator->getErrorMsg();
        }, array_filter($this->validators, function (FormValidator $validator) {
            return !$validator->isValid();
        }));
    }
404249
public function getErrorList()
    {
        $dirIterator = new \RecursiveDirectoryIterator($this->directory);
        $iterator = new \RecursiveIteratorIterator($dirIterator, \RecursiveIteratorIterator::SELF_FIRST);
        $files = array();

        $ignores = $this->ignore;
        $ignores[] = 'phpci.yml';
        $ignores[] = '.phpci.yml';

        foreach ($iterator as $file) {
            $filePath = $file->getRealPath();
            $skipFile = false;
            foreach ($ignores as $ignore) {
                if (stripos($filePath, $ignore) !== false) {
                    $skipFile = true;
                    break;
                }
            }

            // Ignore hidden files, else .git, .sass_cache, etc. all get looped over
            if (stripos($filePath, DIRECTORY_SEPARATOR . '.') !== false) {
                $skipFile = true;
            }

            if ($skipFile == false) {
                $files[] = $file->getRealPath();
            }
        }

        $files = array_filter(array_unique($files));
        $errorCount = 0;

        foreach ($files as $file) {
            foreach ($this->searches as $search) {
                $fileContent = file_get_contents($file);
                $allLines = explode(PHP_EOL, $fileContent);
                $beforeString = strstr($fileContent, $search, true);

                if (false !== $beforeString) {
                    $lines = explode(PHP_EOL, $beforeString);
                    $lineNumber = count($lines);
                    $content = trim($allLines[$lineNumber - 1]);

                    $errorCount++;

                    $fileName = str_replace($this->directory, '', $file);

                    $this->build->reportError(
                        $this->phpci,
                        'technical_debt',
                        $content,
                        PHPCI\Model\BuildError::SEVERITY_LOW,
                        $fileName,
                        $lineNumber
                    );
                }
            }
        }

        return $errorCount;
    }
736347
public function getFailedRecommendations()
    {
        $array = array();
        foreach ($this->requirements as $req) {
            if (!$req->isFulfilled() && $req->isOptional()) {
                $array[] = $req;
            }
        }

        return $array;
    }
476686
public static function withErrors() :array {

		return self::_select()
			->whereNotEmpty('last_failure_date')
			->whereHigherThan('last_failure_date', time() - self::RECENT_FAILURE )
			->limitTo(0, 10)
			->orderBy(['last_failure_date'=>'DESC'])
			->execute();

	}
181379
public function getValidationErrors()
    {
        $errors = $this->errors;

        if (isset($this->validator)) {
            $validator_errors = $this->validator->getErrors();
            $errors = array_merge($errors, $validator_errors);
        }

        return $errors;
    }
691459
protected function getFailedJobs()
	{
		$results = [];

		foreach ($this->laravel['queue.failer']->all() as $failed) {
			$results[] = $this->parseFailedJob((array) $failed);
		}

		return array_filter($results);
	}
825782
protected function getErrors()
    {
        $arr = ['error' => $this->getMessage()];

        if (count($this->attrs) > 0) {
            $arr['attrs'] = $this->getAttrs();
        }

        if (count($this->attrsCustom) > 0) {
            $arr['attrscustom'] = $this->getAttrsCustom();
        }

        return $arr;
    }
38248
public function getAllErrors() {

        $errors = array();
        // First the structure itself
        if ($this->getError()) {
            $errors[] = $this->getError();
        }
        // Delegate to tables
        if ($this->tables) {
            foreach ($this->tables as $table) {
                if ($tableerrors = $table->getAllErrors()) {

                }
            }
            // Add them to the errors array
            if ($tableerrors) {
                $errors = array_merge($errors, $tableerrors);
            }
        }
        // Return decision
        if (count($errors)) {
            return $errors;
        } else {
            return false;
        }
    }
167516
public function getErrorMessages()
    {
        $errors = [];
        foreach ($this->fields as $field) {
            if ($field instanceof AbstractFormField && !$field->isValid()) {
                $fldErrors = $field->getErrorMessages();
                $errors = array_merge($errors, $fldErrors);
            }
        }

        return $errors;
    }
945009
public static function getErrors()
	{
		$list	= array();
		foreach( $this->errors as $errorKey )
			$list[$errorKey]	= self::$rules[$errorKey];
		return $list;
	}