code: @Override
      public Validation validate(Move<? super SolutionType> move,
                                          SolutionType curSolution,
                                          Validation curValidation){
          if(mandatoryConstraints.isEmpty()){
              // CASE 1: no mandatory constraints
              return SimpleValidation.PASSED;
          } else if (mandatoryConstraints.size() == 1){
              // CASE 2: single mandatory constraint
              return mandatoryConstraints.get(0).validate(move, curSolution, curValidation, data);
          } else {
              // CASE 3 (default): aggregate multiple constraint validations
              UnanimousValidation curUnanimousVal = (UnanimousValidation) curValidation;
              UnanimousValidation newUnanimousVal = new UnanimousValidation();
              mandatoryConstraints.stream()
                                  .allMatch(c -> {
                                      // retrieve original validation produced by constraint c
                                      Validation curval = curUnanimousVal.getValidation(c);
                                      if(curval == null){
                                          // current validation unknown: perform full validation
                                          // (can happen due to short-circuiting behaviour)
                                          curval = c.validate(curSolution, data);
                                      }
                                      // validate move against constraint c
                                      Validation newval = c.validate(move, curSolution, curval, data);
                                      // add to unanimous validation
                                      newUnanimousVal.addValidation(c, newval);
                                      // continue until one constraint is not satisfied
                                      return newval.passed();
                                  });
              return newUnanimousVal;
          }
      }
docs: <p>
  Validate a move by checking all mandatory constraints (delta validation).
  The move will only pass validation if all mandatory constraints are satisfied.
  </p>
  <p>
  In case there are no mandatory constraints, this method always returns {@link SimpleValidation#PASSED}.
  If a single mandatory constraint has been specified, the corresponding delta validation is returned. In case
  of two or more constraints, an aggregated validation is constructed that only passes if all constraints are
  satisfied. Short-circuiting is applied: as soon as one violated constraint is found, the remaining constraints
  are not checked.
  </p>
  
  @param move move to validate
  @param curSolution current solution of a local search
  @param curValidation validation of current solution
  @throws IncompatibleDeltaValidationException if the provided delta validation of any mandatory
  constraint is not compatible with the received move type
  @return aggregated delta validation