Returns the data which was invalid.

@return array
193959
public function invalid()
    {
        if (! $this->messages) {
            $this->passes();
        }

        return array_intersect_key(
            $this->data, $this->attributesThatHaveMessages()
        );
    }
79895
public function getData()
    {
        $this->validateParams();

        $data = [
            'service'        => $this->service,
            'partner'        => $this->getPartner(),
            'trade_no'       => $this->getTradeNo(),
            'out_trade_no'   => $this->getOutTradeNo(),
            '_input_charset' => $this->getInputCharset(),
            'sign_type'      => $this->getSignType()
        ];
        $data['sign'] = $this->sign($data, $this->getSignType());
        
        return $data;
    }
942712
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if ($this->container['typeId'] === null) {
            $invalidProperties[] = "'typeId' can't be null";
        }
        if ($this->container['quantity'] === null) {
            $invalidProperties[] = "'quantity' can't be null";
        }
        if ($this->container['locationId'] === null) {
            $invalidProperties[] = "'locationId' can't be null";
        }
        if ($this->container['locationType'] === null) {
            $invalidProperties[] = "'locationType' can't be null";
        }
        $allowedValues = $this->getLocationTypeAllowableValues();
        if (!in_array($this->container['locationType'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'locationType', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['itemId'] === null) {
            $invalidProperties[] = "'itemId' can't be null";
        }
        if ($this->container['locationFlag'] === null) {
            $invalidProperties[] = "'locationFlag' can't be null";
        }
        $allowedValues = $this->getLocationFlagAllowableValues();
        if (!in_array($this->container['locationFlag'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'locationFlag', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['isSingleton'] === null) {
            $invalidProperties[] = "'isSingleton' can't be null";
        }
        return $invalidProperties;
    }
405426
public function getFormErrors ()
    {
        return array_map(function (FormValidator $formValidator) {
            return $formValidator->getErrorMsg();
        }, array_filter($this->validators, function (FormValidator $validator) {
            return !$validator->isValid();
        }));
    }
39868
public function getData()
    {
        $data = [];

        $problems = $this->fetcher->fetch();

        $allowedSeverities = [
            Problem::SEVERITY_CRITICAL,
            Problem::SEVERITY_WARNING,
        ];

        foreach ($problems as $problem) {
            if (!in_array($problem->getSeverity(), $allowedSeverities)) {
                continue;
            }

            $data[] = [
                'id' => strlen($problem->getId()) ? $problem->getId() : md5(serialize($problem)),
                'iconCls' => $problem->getIconClass(),
                'severity' => $problem->getSeverity(),
                'msg' => $problem->getMessage(),
                'hint' => $problem->getHint(),
                'link' => $problem->getLink(),
            ];
        }

        if (!count($data)) {
            $data = false;
        }

        return $data;
    }
11917
public function getErrors(): array
    {
        if ($this->errors === null) {
            $this->errors = $this->fetchErrors();
        }

        //Making sure that each error point to proper input origin
        return $this->mapper->mapErrors($this, $this->validateNested($this->errors));
    }
1076658
public function getErrors()
    {
        if (!$this->validator || !$this->validator instanceof Validator) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Form %s was not validated. To validate it, call "isValid" method before retrieving the errors',
                    get_class($this)
                )
            );
        }

        return $this->validator->getMessageBag()->getMessages();
    }
1051531
public function getErrors(): array
    {
        $errors = $this->validate()->getErrors();
        foreach ($errors as &$error) {
            if (is_string($error) && Translator::isMessage($error)) {
                // translate error message
                $error = $this->say($error);
            }

            unset($error);
        }

        return $errors;
    }
863305
public function getData()
    {
        foreach ($this->data as $value) {
            $this->validateDefinitions($value);
        }
        return ['data' => $this->data, 'parent_aliases' => $this->parentAliases];
    }
1227080
public function listInvalidProperties()
    {
        $invalidProperties = [];

        $allowedValues = $this->getHighGradeAllowableValues();
        if (!in_array($this->container['high_grade'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'high_grade', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        $allowedValues = $this->getLowGradeAllowableValues();
        if (!in_array($this->container['low_grade'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'low_grade', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        return $invalidProperties;
    }
388826
public function getErrors()
    {
        if ($this->errors === null) {
            if ($errors = $this['errors']) {
                foreach ($errors as $key => $error) {
                    $errors[$key] = $this->shapeFor($error);
                }
                $this->errors = $errors;
            } else {
                $this->errors = [];
            }
        }

        return $this->errors;
    }
722514
public function getValidationErrors()
    {
        if ($this->isValid()) {
            return [];
        }
        
        // if it's already cached, just return it
        if (count($this->validationErrors) > 0) {
            return $this->validationErrors;
        }


        // All errors can be spotted in the fields
        foreach ($this->getFields() as $field) {
            if (!$field->isValid()) {
                $this->validationErrors[$field->getName()] = $field->getErrors(true);
            }
        }

        return $this->validationErrors;
    }
1137392
public function errorInfo()
    {
        $e = oci_error($this->sth);

        if (is_array($e)) {
            return [
                'HY000',
                $e['code'],
                $e['message'],
            ];
        }

        return ['00000', null, null];
    }
1347309
protected function buildErrorData()
    {
        if (is_null($this->errorCode)) {
            return null;
        }

        $data = [
            'code' => $this->errorCode,
            'message' => $this->message ?: $this->resolveMessage()
        ];

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

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

        return $this->errors;
    }
942027
public function getInvalidFields()
    {
        $invalidFields = array();
        foreach ($this->currentFields as $field) {
            if (!$field->isValid) {
                $invalidFields[] = $field;
            }
        }
        return $invalidFields;
    }
277617
public function getData()
    {
        $this->validateParams();

        $this->setDefaults();

        $this->convertToString();

        $data = $this->parameters->all();

        $data['method'] = $this->method;

        ksort($data);

        $data['sign'] = $this->sign($data, $this->getSignType());

        return $data;
    }