Shows the validation error dialog.<p>

@param validationResult the validation result
171545
void showValidationErrorDialog(CmsValidationResult validationResult) {

        if (validationResult.getErrors().keySet().contains(m_entityId)) {
            getValidationHandler().displayValidation(m_entityId, validationResult);
        }
        String errorLocales = "";
        for (String entityId : validationResult.getErrors().keySet()) {
            String locale = CmsContentDefinition.getLocaleFromId(entityId);
            errorLocales += m_availableLocales.get(locale) + ", ";
        }
        // remove trailing ','
        errorLocales = errorLocales.substring(0, errorLocales.length() - 2);
        CmsErrorDialog dialog = new CmsErrorDialog(
            Messages.get().key(Messages.GUI_VALIDATION_ERROR_1, errorLocales),
            null);
        dialog.center();
    }
1346649
public function validate(ValidationResult $validationResult)
    {
        // The object is new, won't be looping.
        /** @var DataObject|Hierarchy $owner */
        $owner = $this->owner;
        if (!$owner->ID) {
            return;
        }
        // The object has no parent, won't be looping.
        if (!$owner->ParentID) {
            return;
        }
        // The parent has not changed, skip the check for performance reasons.
        if (!$owner->isChanged('ParentID')) {
            return;
        }

        // Walk the hierarchy upwards until we reach the top, or until we reach the originating node again.
        $node = $owner;
        while ($node && $node->ParentID) {
            if ((int)$node->ParentID === (int)$owner->ID) {
                // Hierarchy is looping.
                $validationResult->addError(
                    _t(
                        __CLASS__ . '.InfiniteLoopNotAllowed',
                        'Infinite loop found within the "{type}" hierarchy. Please change the parent to resolve this',
                        'First argument is the class that makes up the hierarchy.',
                        array('type' => get_class($owner))
                    ),
                    'bad',
                    'INFINITE_LOOP'
                );
                break;
            }
            $node = $node->Parent();
        }
    }
1184450
public void validate() {
    StringBuilder validationErrorBuilder = new StringBuilder("Process engine configuration is invalid: \n");
    boolean isValid = true;    
    
    if(datasourceJndiName == null || datasourceJndiName.isEmpty()) {
      isValid = false;
      validationErrorBuilder.append(" property 'datasource' cannot be null \n");      
    }
    if(engineName == null || engineName.isEmpty()) {
      isValid = false;
      validationErrorBuilder.append(" property 'engineName' cannot be null \n");
    }

    for (int i = 0; i < pluginConfigurations.size(); i++) {
      ProcessEnginePluginXml pluginConfiguration = pluginConfigurations.get(i);
      if (pluginConfiguration.getPluginClass() == null || pluginConfiguration.getPluginClass().isEmpty()) {
        isValid = false;
        validationErrorBuilder.append(" property 'class' in plugin[" + i + "] cannot be null \n");
      }
    }
    
    if(!isValid) {
      throw new ProcessEngineException(validationErrorBuilder.toString());
    }
  }
1222417
def validate(self) -> ValidationResult:
        
        result = ValidationResult()
        try:
            for rule in self.get_rules():
                try:
                    if not rule.apply():
                        result.annotate_rule_violation(rule)
                        if rule.stop_if_invalid:
                            break
                except Exception as e:
                    result.annotate_exception(e, rule)
        except Exception as e:
            result.annotate_exception(e, None)
        return result
1351372
public boolean isValid() {
        for (ValidationResult result : results) {
            for (ValidationMessage<Origin> message : result.getMessages()) {
                if (Severity.ERROR.equals(message.getSeverity())) {
                    return false;
                }
            }
        }
        return true;
    }
189306
public function validate() {
		parent::validate();

		if ($this->getName() === null) {
			throw new ValidationException("'name' can't be null", 'name', $this);
		}
		if ($this->getType() === null) {
			throw new ValidationException("'type' can't be null", 'type', $this);
		}
	}
549860
public void validate(final List<Throwable> validationErrors) {
        if (this.matchers == null) {
            validationErrors.add(new IllegalArgumentException(
                    "Matchers cannot be null.  There should be at least a !acceptAll matcher"));
        }
        if (this.matchers != null && this.matchers.isEmpty()) {
            validationErrors.add(new IllegalArgumentException(
                    "There are no url matchers defined.  There should be at least a " +
                            "!acceptAll matcher"));
        }
    }
1319426
@ExceptionHandler(MethodArgumentNotValidException.class)
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  @ResponseBody
  public ValidationResultInterface processValidationError(
      final MethodArgumentNotValidException pexception) {
    final BindingResult result = pexception.getBindingResult();
    final List<FieldError> fieldErrors = result.getFieldErrors();

    return processFieldErrors(fieldErrors);
  }
170779
public void setValidationErrors(java.util.Collection<ValidationError> validationErrors) {
        if (validationErrors == null) {
            this.validationErrors = null;
            return;
        }

        this.validationErrors = new com.amazonaws.internal.SdkInternalList<ValidationError>(validationErrors);
    }
1019966
public void validate(String path, Schema schema, Object value, List<ValidationResult> results) {
		String name = path != null ? path : "value";

		if (!ObjectComparator.compare(value, _operation, _value)) {
			results.add(new ValidationResult(path, ValidationResultType.Error, "BAD_VALUE",
					name + " must " + _operation + " " + _value + " but found " + value, _operation + " " + _value,
					value));
		}
	}
1206312
public void add(ValidationResult validation) {
    correct &= validation.correct;
    if (!validate) return;
    errors.addAll(validation.errors);
    warnings.addAll(validation.warnings);
  }
1109258
func (v *Validation) ValidationResult(ok bool) *ValidationResult {
	if ok {
		return &ValidationResult{Ok: ok}
	} else {
		return &ValidationResult{Ok: ok, Error: &ValidationError{}, Locale: v.Request.Locale, Translator: v.Translator}
	}
}
77588
public ValidationResult check(Entry entry)
	{
		result = new ValidationResult();

		if (entry.isDelete())
		{
			reportMessage(Severity.FIX, entry.getOrigin(), FIX_ID, entry.getPrimaryAccession());
		}
		return result;
	}
87437
public void addInvalidAttributeError(final String type) throws ValidationException
    {
        addError(StringFormatter.format(MessageConstants.MESSAGES.attributeIsInvalidForType(), type));
    }
90719
private void validateSingleAliasRow(CmsObject cms, CmsAliasTableRow row) {

        Locale locale = OpenCms.getWorkplaceManager().getWorkplaceLocale(cms);
        if (row.getStructureId() == null) {
            String path = row.getResourcePath();
            try {
                CmsResource resource = cms.readResource(path, CmsResourceFilter.ALL);
                row.setStructureId(resource.getStructureId());
                if (row.getOriginalStructureId() == null) {
                    row.setOriginalStructureId(resource.getStructureId());
                }
            } catch (CmsException e) {
                row.setPathError(messageResourceNotFound(locale));
                m_hasErrors = true;
            }
        }
        if (!CmsAlias.ALIAS_PATTERN.matcher(row.getAliasPath()).matches()) {
            row.setAliasError(messageInvalidAliasPath(locale));
            m_hasErrors = true;
        }
    }
931278
private void validateDialog() throws Exception {

        CmsResource.checkResourceName(m_sitename);
        m_sitename = ensureFoldername(m_sitename);
        if (CmsStringUtil.isEmptyOrWhitespaceOnly(m_site.getServer())) {
            // the server's URL must not be empty or null
            throw new CmsException(Messages.get().container(Messages.ERR_SERVER_URL_NOT_EMPTY_0));
        }
    }
999142
public void add(ValidationResultsModel validationResultsModel) {
		if (children.add(validationResultsModel)) {
			validationResultsModel.addValidationListener(this);
			validationResultsModel.addPropertyChangeListener(HAS_ERRORS_PROPERTY, this);
			validationResultsModel.addPropertyChangeListener(HAS_WARNINGS_PROPERTY, this);
			validationResultsModel.addPropertyChangeListener(HAS_INFO_PROPERTY, this);
			if ((validationResultsModel.getMessageCount() > 0))
				fireChangedEvents();
		}
	}