Second ValidationResultFields will over-ride the first

@param ValidationResultFields $validationResultFields
@param ValidationResultFields $validationResultFieldsMore

@return ValidationResultFields
@throws \Exception
484244
public static function invoke(
        ValidationResultFields $validationResultFields,
        ValidationResultFields $validationResultFieldsMore
    ): ValidationResultFields {
        $code = '';

        if (!$validationResultFields->isValid()) {
            $code = $validationResultFields->getCode();
        }

        if (!$validationResultFieldsMore->isValid()) {
            $code = $validationResultFieldsMore->getCode();
        }

        $isValid = ($validationResultFields->isValid() && $validationResultFieldsMore->isValid());

        $details = array_merge(
            $validationResultFields->getDetails(),
            $validationResultFieldsMore->getDetails()
        );

        $mergedFieldResults = array_merge(
            $validationResultFields->getFieldResults(),
            $validationResultFieldsMore->getFieldResults()
        );

        return new ValidationResultFieldsBasic(
            $isValid,
            $code,
            $details,
            $mergedFieldResults
        );
    }
192421
public function validate(EiField $eiField, EiFieldValidationResult $validationResult) {
		return $this->validatable->validateEiFieldValue($this->eiu, $eiField->getValue(), $validationResult);
	}
502582
public function validate(AbstractValidator $validator, $removeRequired = false, array $messages = [], array $customAttributes = [])
    {
        return $validator->validate($removeRequired);
        /*try {
            return $validator->validate($removeRequired);
        } catch (ValidationException $e) {
            $this->throwValidationException($e->getErrors());
        }*/

//              $this->throwValidationException($request, $validator);
        // $validator = $this->getValidationFactory()->make($request->all(), $rules, $messages, $customAttributes);

    }
1280296
protected function getFieldValidationResults(
        array $fields,
        array $allowedFields = [],
        array $fieldResults = [],
        array $options = []
    ): array {
        foreach ($fields as $fieldName => $value) {
            if (!in_array($fieldName, $allowedFields)) {
                $fieldResults[$fieldName] = new ValidationResultBasic(
                    false,
                    BuildOptionCode::invoke($options, static::CODE_UNRECOGNIZED_FIELD),
                    ['message' => 'Unrecognized field received: (' . $fieldName . ')']
                );
            }
        }

        return $fieldResults;
    }
556392
@Override
    public ValidationResult validate(PMContext ctx) {
        final ValidationResult res = new ValidationResult();
        final String fieldvalue = (String) ctx.getFieldValue();
        res.setSuccessful(true);
        if (!isName(fieldvalue)) {
            res.setSuccessful(false);
            res.getMessages().add(MessageFactory.error(ctx.getEntity(), ctx.getField(), get("msg", "")));
        }
        return res;
    }
139445
public function findFieldResult(string $fieldName): ValidationResult
    {
        if (!array_key_exists($fieldName, $this->fieldResults)) {
            throw new FieldDoesNotExist(
                'Field does not exist: ' . $fieldName
            );
        }

        return $this->fieldResults[$fieldName];
    }
98698
public function add(ValidationResult $validation, $prefix = null)
    {
        $prefix = $this->translate($prefix);
    
        foreach ($validation->getErrors() as $err) {
            $this->errors[] = ($prefix ? trim($prefix) . ' ' : '') . $err; 
        }
    }
322966
@Override
    public ValidationResult validate(PMContext ctx) {
        final ValidationResult res = new ValidationResult();
        final Object object = ctx.getFieldValue();
        final String fieldId = ctx.getField().getId();

        if (object instanceof String) {
            String fieldvalue = (String) object;
            res.setSuccessful(true);
            Integer len = fieldvalue.length();
            Integer maxl = getInt("max-length");
            if (maxl != null) {
                if (len > maxl) {
                    res.setSuccessful(false);
                    res.getMessages().add(MessageFactory.error(
                            ctx.getEntity(), ctx.getField(),
                            get("max-length-msg", "pm_core.validator.toolong"),
                            fieldId, len.toString(), maxl.toString()));
                }
            }
            Integer minl = getInt("min-length");
            if (minl != null) {
                if (len < minl) {
                    res.setSuccessful(false);
                    res.getMessages().add(MessageFactory.error(
                            ctx.getEntity(), ctx.getField(),
                            get("min-length-msg", "pm_core.validator.tooshort"),
                            fieldId, len.toString(), minl.toString()));
                }
            }
        } else {
            res.setSuccessful(false);
            res.getMessages().add(MessageFactory.error(
                    ctx.getEntity(), ctx.getField(),
                    "pm_core.validator.fieldnotstring",
                    fieldId));
        }
        return res;
    }
1270294
protected function validateValue($value, EiFieldValidationResult $validationResult) {
		if ($value != null) {
			CastUtils::assertTrue($value instanceof EiuFieldMap);
			
			$eiEntryValidationResult = new EiEntryValidationResult();
			$validationResult->addSubEiEntryValidationResult($eiEntryValidationResult);
			$value->validate($eiEntryValidationResult);
			return;
		}
		
		if ($this->eiProp->isMandatory()) {
			$validationResult->addError(Message::createCodeArg('common_field_required_err', 
					['field' => $this->eiProp->getLabelLstr()->t($this->eiu->getN2nLocale())], null, 'rocket'));
		}
	}
926593
public function validateValidatorConfiguration($validatorConfiguration)
    {
        $validationErrors = array();

        foreach ($validatorConfiguration as $validatorIdentifier => $constraints) {
            if ($validatorIdentifier !== 'FloatValueValidator') {
                $validationErrors[] = new ValidationError(
                    "Validator '%validator%' is unknown",
                    null,
                    array(
                        '%validator%' => $validatorIdentifier,
                    ),
                    "[$validatorIdentifier]"
                );

                continue;
            }

            foreach ($constraints as $name => $value) {
                switch ($name) {
                    case 'minFloatValue':
                    case 'maxFloatValue':
                        if ($value !== null && !is_numeric($value)) {
                            $validationErrors[] = new ValidationError(
                                "Validator parameter '%parameter%' value must be of numeric type",
                                null,
                                array(
                                    '%parameter%' => $name,
                                ),
                                "[$validatorIdentifier][$name]"
                            );
                        }
                        break;
                    default:
                        $validationErrors[] = new ValidationError(
                            "Validator parameter '%parameter%' is unknown",
                            null,
                            array(
                                '%parameter%' => $name,
                            ),
                            "[$validatorIdentifier][$name]"
                        );
                }
            }
        }

        return $validationErrors;
    }
1329865
private function validateAllRequired($isCreating) {
        foreach($this->getFiles() as $file) {
            if(!$file->isUsed()) {
                if($isCreating ? $file->isRequiredOnCreate() : $file->isRequiredOnUpdate()) {
                    $this->getEntity()->appendMessage(new Message('Missing the required file of: ' . $file->getName()));
                }
            }
        }
        if($this->getEntity()->validationHasFailed() == true) {
            $validationException = new ValidationException();
            $validationException->setEntity($this->getEntity());
            throw $validationException;
        }
    }
492192
public function validateValue($value) {
        $validationResultSet = new ValidationResultSet();
        foreach($this->validators as $validator) {
            $validationResultSet->add($validator->validate($value));
        }
        return $validationResultSet;
    }
1322676
private function callValidators($value, ValidationField $field) {
        $valid = true;

        // Strip array references in the name except for the last one.
        $key = $field->getSchemaPath();
        if (!empty($this->validators[$key])) {
            foreach ($this->validators[$key] as $validator) {
                $r = call_user_func($validator, $value, $field);

                if ($r === false || Invalid::isInvalid($r)) {
                    $valid = false;
                }
            }
        }

        // Add an error on the field if the validator hasn't done so.
        if (!$valid && $field->isValid()) {
            $field->addError('invalid', ['messageCode' => 'The value is invalid.']);
        }
    }
79882
public function validate() {

		if ($this->getEndAction() === null) {
			throw new ValidationException("'endAction' can't be null", 'endAction', $this);
		}
		if ($this->getPlannedEndDate() === null) {
			throw new ValidationException("'plannedEndDate' can't be null", 'plannedEndDate', $this);
		}
		if ($this->getSubscription() === null) {
			throw new ValidationException("'subscription' can't be null", 'subscription', $this);
		}
	}
726066
private function getValidatedFields(iterable $fieldsFromParent): iterable
    {
        $ruleIndexes = $this->serializerClass::readFieldSetRulesIndexes($this->getSerializedRuleSet());

        if ($ruleIndexes === null) {
            // without validation
            foreach ($fieldsFromParent as $type => $fieldList) {
                yield $type => $fieldList;
            }
        } else {
            // with validation
            $mainIndexes = $this->serializerClass::readRuleMainIndexes($ruleIndexes);
            $this->validationStarts(static::PARAM_FIELDS, $ruleIndexes);
            foreach ($fieldsFromParent as $type => $fieldList) {
                if (array_key_exists($type, $mainIndexes) === true) {
                    yield $type => $this->validateValues($mainIndexes[$type], $fieldList);
                } else {
                    // unknown field set type
                    $this->getValidationErrors()->add(
                        new ValidationError(
                            static::PARAM_FIELDS,
                            $type,
                            ErrorCodes::INVALID_VALUE,
                            Messages::INVALID_VALUE,
                            []
                        )
                    );
                }
            }
            $this->validateEnds(static::PARAM_FIELDS, $ruleIndexes);
        }
    }
932782
private function validateNumberProperties($value, ValidationField $field) {
        $count = $field->getErrorCount();

        if ($multipleOf = $field->val('multipleOf')) {
            $divided = $value / $multipleOf;

            if ($divided != round($divided)) {
                $field->addError('multipleOf', ['messageCode' => 'The value must be a multiple of {multipleOf}.', 'multipleOf' => $multipleOf]);
            }
        }

        if ($maximum = $field->val('maximum')) {
            $exclusive = $field->val('exclusiveMaximum');

            if ($value > $maximum || ($exclusive && $value == $maximum)) {
                if ($exclusive) {
                    $field->addError('maximum', ['messageCode' => 'The value must be less than {maximum}.', 'maximum' => $maximum]);
                } else {
                    $field->addError('maximum', ['messageCode' => 'The value must be less than or equal to {maximum}.', 'maximum' => $maximum]);
                }
            }
        }

        if ($minimum = $field->val('minimum')) {
            $exclusive = $field->val('exclusiveMinimum');

            if ($value < $minimum || ($exclusive && $value == $minimum)) {
                if ($exclusive) {
                    $field->addError('minimum', ['messageCode' => 'The value must be greater than {minimum}.', 'minimum' => $minimum]);
                } else {
                    $field->addError('minimum', ['messageCode' => 'The value must be greater than or equal to {minimum}.', 'minimum' => $minimum]);
                }
            }
        }

        return $field->getErrorCount() === $count ? $value : Invalid::value();
    }
215198
protected static function validateInput($value, $validationClass, $validationMethod, $exceptionClass, $exceptionMsg)
    {
        $value = \call_user_func_array([$validationClass, $validationMethod], [$value]);
        if (false === $value) {
            throw new $exceptionClass($exceptionMsg);
        }

        return $value;
    }