Validation

scriptTask("SolveMultipleResults", DV_PROJECT){
  code{
    validation{
      assert validationResults.size() == 4
      solver.solve{
        // Call result() and pass a closure that works as filter
        // based on methods of IValidationResultUI.
        result{
          isId("TP", 12)
        }
        // On the return value, call withAction() and pass a closure that
        // selects a solving-action based on methods
        // of IValidationResultForSolvingActionSelect
        .withAction{
          containsString("next bigger valid value")
        }

        // multiple result() calls can be placed in one solve() call.
        result{isId("COM", 34)}.withAction{containsString("recalculate")}
      }

      // Three TP12 and zero COM34 (didn't exist) results solved. One other left
      assert validationResults.size() == 1
}}}

scriptTask("IValidationResultUIErroneousCEs", DV_PROJECT){
    code{
        validation{
            // sampleDefRefs contains DefRef constants just for this example. Please use the real DefRefs from your SIP

            def result = validationResults.filter{it.isId("TP", 12)}.first

            // Retrieve the model element to check
            def modelElement // = retrieveElement ...

            // Check if the model object is affected by the validation-result
            assert result.matchErroneousCE(modelElement)

        }
    }
}

scriptTask("CheckValidationResultsOfObject", DV_PROJECT){
    code{
        // sampleDefRefs contains DefRef constants just for this example. Please use the real DefRefs from your SIP

        // a Buffer container
        def buffer002 = mdfModel(AsrPath.create("/ActiveEcuC/Tp/Buffer_002"))
        // the Size parameter
        def sizeParam = buffer002.parameter(sampleDefRefs.tpBufferSizeDefRef).single

        // the result exists for the Size parameter, not for the Buffer container
        assert sizeParam.validationResults.size() == 1
        assert buffer002.validationResults.size() == 0
    }
}

IValidationResultUI.matchErroneousCE(theObject) &&
(
  IValidationResultUI.isGeneralVariantContext() ||
  IValidationResultUI.getPredefinedVariantContexts().contains(theView)
)

scriptTask("CheckValidationResultsOfDefRef", DV_PROJECT){
    code{
        // sampleDefRefs contains DefRef constants just for this example. Please use the real DefRefs from your SIP

        assert sampleDefRefs.tpBufferSizeDefRef.validationResults.size() == 3
    }
}

scriptTask("FilterResultsUsingAnIdConstant2", DV_PROJECT){
    code{
        validation{
            def tp12Const = ["TP",12]

            assert validationResults.size() > 3
            assert validationResults.filter{it.isId(*tp12Const)}.size() == 3
        }
    }
}

final String SA_GROUP_ID_TP12_NEXT_BIGGER_VALID_VALUE = "ESolvingActionGroup#2"

scriptTask("SolveMultipleResultsByGroupId", DV_PROJECT){
  code{
    validation{
      assert validationResults.size() == 4

      solver.solve{
        result{isId("TP", 12)}
          .withAction{
            byGroupId(SA_GROUP_ID_TP12_NEXT_BIGGER_VALID_VALUE)
          }
          // instead of .withAction{containsString("next bigger valid value")}
      }

      assert validationResults.size() == 1
      // Three TP12 validation-results solved.
    }
  }
}

scriptTask("IValidationResultUIApiOverview", DV_PROJECT){
  code{
    validation{
      def r = validationResults.filter{it.isId("TP", 12)}.first
      assert r.id.origin == "TP"
      assert r.id.id == 12
      assert r.description.toString().contains("must be a multiple of")
      assert r.severity == EValidationSeverityType.ERROR
      assert r.solvingActions.size() == 2
      assert r.getSolvingActionByGroupId("ESolvingActionGroup#2").description.contains("next bigger valid value")

      // this result has a preferred-solving-action
      assert r.preferredSolvingAction == r.getSolvingActionByGroupId("ESolvingActionGroup#2")

      // results with lower severity than ERROR can be acknowledged
      assert r.acknowledgement.isPresent() == false

      // if the cause was an exception, r.cause.get() returns it
      assert r.cause.isPresent() == false

      // an ERROR result gets reduced to WARNING if one of its erroneous CEs is user-defined (user-overridden)
      assert r.isReducedSeverity() == false

      // on-demand results are reported with the on-demand generator validation
      assert r.isOnDemandResult() == false
    }
  }
}

scriptTask("IValidationResultUIInAVariantProject", DV_PROJECT){
    code{
        validation{
            def r = validationResults.filter{it.isId("TP", 12)}.first
            assert r.isGeneralVariantContext() // either it is a general result...
            assert r.predefinedVariantContexts.size() == 0 // or it is assigned to one or more (but never all) variants
            // If a validator assigns a result to all variants, it will be a general result at UI-side.
        }
    }
}

import com.vector.cfg.util.activity.execresult.EExecutionResult

scriptTask("SolvingReturnValue", DV_PROJECT){
    code{
        validation{
           assert validationResults.size() == 4
           // In this example, three validation-results have a preferred solving action.
           // One of the three cannot be solved because a parameter is user-defined.
           def summaryResult = solver.solveAllWithPreferredSolvingAction()
           assert validationResults.size() == 2 // Two have been solved, one with a preferred solving-action is left.
           assert summaryResult.executionResult == EExecutionResult.WARNING

           // DemoAsserts is just for this example to show what kind of sub-results the summaryResult contains.
           DemoAsserts.summaryResultContainsASubResultWith("OK",summaryResult)
           //two such sub-results for the validation-results with preferred-solving-action that could be solved

           DemoAsserts.summaryResultContainsASubResultWith(["invalid modification","not changeable","Reason","is user-defined"],summaryResult)
           // such a sub-result for the failed preferred solving action due to the user-defined parameter

           DemoAsserts.summaryResultContainsASubResultWith("Maximum solving attempts reached for the validation-result of the following solving-action",summaryResult)
           // Multiple attempts are taken to solve a result because other changes may eliminate a blocking reason, but stops after an execution limit is reached.
        }
    }
}

scriptTask("SolvingReturnValue", DV_PROJECT){
    code{
        validation{
            settings{
                if (autoSolvingActionExecution.changeable) {
                    autoSolvingActionExecution.enabled = false
                }
            }
        }
    }
}