public ExpressionEvaluationContext shallowClone() { ExpressionEvaluationContext clone = new ExpressionEvaluationContext(sources, variables, contextDescription, task, result); clone.skipEvaluationMinus = this.skipEvaluationMinus; clone.skipEvaluationPlus = this.skipEvaluationPlus; clone.valuePolicyResolver = this.valuePolicyResolver; clone.expressionFactory = this.expressionFactory; clone.defaultSource = this.defaultSource; clone.refinedObjectClassDefinition = this.refinedObjectClassDefinition; clone.mappingQName = this.mappingQName; clone.additionalConvertor = this.additionalConvertor; clone.variableProducer = this.variableProducer; return clone; }
private List<NotificationMessageType> evaluateExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismPropertyDefinition<NotificationMessageType> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, NotificationMessageType.COMPLEX_TYPE); Expression<PrismPropertyValue<NotificationMessageType>,PrismPropertyDefinition<NotificationMessageType>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<NotificationMessageType>> exprResult = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, params, task, result); return exprResult.getZeroSet().stream().map(PrismPropertyValue::getValue).collect(Collectors.toList()); } }
public boolean evaluateBooleanExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismPropertyDefinition<Boolean> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, DOMUtil.XSD_BOOLEAN); Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> exprResultTriple = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, params, task, result); Collection<PrismPropertyValue<Boolean>> exprResult = exprResultTriple.getZeroSet(); if (exprResult.size() == 0) { return false; } else if (exprResult.size() > 1) { throw new IllegalStateException("Filter expression should return exactly one boolean value; it returned " + exprResult.size() + " ones"); } Boolean boolResult = exprResult.iterator().next().getValue(); return boolResult != null ? boolResult : false; }
private boolean evaluateBooleanExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String opContext, Task taskFromModel, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { PrismContext prismContext = expressionFactory.getPrismContext(); QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismPropertyDefinition<Boolean> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, DOMUtil.XSD_BOOLEAN); Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> expression = expressionFactory.makeExpression(expressionType, resultDef, opContext, taskFromModel, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, opContext, taskFromModel, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> exprResultTriple = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, params, taskFromModel, result); Collection<PrismPropertyValue<Boolean>> exprResult = exprResultTriple.getZeroSet(); if (exprResult.size() == 0) { return false; } else if (exprResult.size() > 1) { throw new IllegalStateException("Expression should return exactly one boolean value; it returned " + exprResult.size() + " ones"); } Boolean boolResult = exprResult.iterator().next().getValue(); return boolResult != null ? boolResult : false; }
private void evaluateExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismPropertyDefinition<String> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, DOMUtil.XSD_STRING); Expression<PrismPropertyValue<String>,PrismPropertyDefinition<String>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); ModelExpressionThreadLocalHolder.evaluateExpressionInContext(expression, params, task, result); }
public List<NotificationMessageAttachmentType> evaluateNotificationMessageAttachmentTypeExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismPropertyDefinition<NotificationMessageAttachmentType> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, NotificationMessageAttachmentType.COMPLEX_TYPE); Expression<PrismPropertyValue<NotificationMessageAttachmentType>,PrismPropertyDefinition<NotificationMessageAttachmentType>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<NotificationMessageAttachmentType>> exprResultTriple = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, params, task, result); Collection<PrismPropertyValue<NotificationMessageAttachmentType>> exprResult = exprResultTriple.getZeroSet(); if (exprResult.size() == 0) { return null; } List<NotificationMessageAttachmentType> retval = new ArrayList<>(); for (PrismPropertyValue<NotificationMessageAttachmentType> item : exprResult) { retval.add(item.getValue()); } return retval; }
@NotNull private List<String> evaluateExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, boolean multipleValues, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { if (expressionType == null) { return multipleValues ? emptyList() : singletonList(null); } QName resultName = new QName(SchemaConstants.NS_C, "result"); MutablePrismPropertyDefinition<String> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, DOMUtil.XSD_STRING); if (multipleValues) { resultDef.setMaxOccurs(-1); } Expression<PrismPropertyValue<String>,PrismPropertyDefinition<String>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<String>> exprResult = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, params, task, result); if (!multipleValues) { if (exprResult.getZeroSet().size() > 1) { throw new SystemException("Invalid number of return values (" + exprResult.getZeroSet().size() + "), expected at most 1."); } else if (exprResult.getZeroSet().isEmpty()) { return singletonList(null); } else { // single-valued response is treated below } } return exprResult.getZeroSet().stream().map(ppv -> ppv.getValue()).collect(Collectors.toList()); }
@SuppressWarnings("SameParameterValue") private <T> List<T> evaluateExpression(Class<T> resultClass, ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName xsdType = XsdTypeMapper.toXsdType(resultClass); QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismPropertyDefinition<T> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, xsdType); Expression<PrismPropertyValue<T>,PrismPropertyDefinition<T>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<T>> exprResult = ModelExpressionThreadLocalHolder.evaluateExpressionInContext(expression, params, task, result); List<T> retval = new ArrayList<>(); for (PrismPropertyValue<T> item : exprResult.getZeroSet()) { retval.add(item.getValue()); } return retval; }
public static <T> T evaluateExpressionSingle(ExpressionType expressionBean, ExpressionVariables expressionVariables, String contextDescription, ExpressionFactory expressionFactory, PrismContext prismContext, Task task, OperationResult result, QName typeName, T defaultValue, Function<Object, Object> additionalConvertor) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { PrismPropertyDefinition<T> resultDef = prismContext.definitionFactory().createPropertyDefinition( new QName(SchemaConstants.NS_C, "result"), typeName); Expression<PrismPropertyValue<T>,PrismPropertyDefinition<T>> expression = expressionFactory.makeExpression(expressionBean, resultDef, contextDescription, task, result); ExpressionEvaluationContext eeContext = new ExpressionEvaluationContext(null, expressionVariables, contextDescription, task, result); eeContext.setAdditionalConvertor(additionalConvertor); PrismValueDeltaSetTriple<PrismPropertyValue<T>> exprResultTriple = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, eeContext, task, result); List<T> results = exprResultTriple.getZeroSet().stream() .map(ppv -> (T) ppv.getRealValue()) .collect(Collectors.toList()); return getSingleValue(results, defaultValue, contextDescription); }
private List<String> evaluateExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName resultName = new QName(SchemaConstants.NS_C, "result"); MutablePrismPropertyDefinition<String> resultDef = prismContext.definitionFactory().createPropertyDefinition(resultName, DOMUtil.XSD_STRING); resultDef.setMaxOccurs(-1); Expression<PrismPropertyValue<String>,PrismPropertyDefinition<String>> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<String>> exprResult = ModelExpressionThreadLocalHolder .evaluateExpressionInContext(expression, params, task, result); List<String> retval = new ArrayList<>(); for (PrismPropertyValue<String> item : exprResult.getZeroSet()) { retval.add(item.getValue()); } return retval; }
public String evaluateExpression(ShadowType shadow, ExpressionType expressionType, String shortDesc, Task task, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException { Validate.notNull(shadow, "Resource object shadow must not be null."); Validate.notNull(expressionType, "Expression must not be null."); Validate.notNull(result, "Operation result must not be null."); ResourceType resource = resolveResource(shadow, result); ExpressionVariables variables = getDefaultXPathVariables(null, shadow, resource); PrismPropertyDefinition<String> outputDefinition = prismContext.definitionFactory().createPropertyDefinition(ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_STRING); Expression<PrismPropertyValue<String>,PrismPropertyDefinition<String>> expression = expressionFactory.makeExpression(expressionType, outputDefinition, shortDesc, task, result); ExpressionEvaluationContext params = new ExpressionEvaluationContext(null, variables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<String>> outputTriple = ModelExpressionThreadLocalHolder.evaluateExpressionInContext(expression, params, task, result); if (outputTriple == null) { return null; } Collection<PrismPropertyValue<String>> nonNegativeValues = outputTriple.getNonNegativeValues(); if (nonNegativeValues == null || nonNegativeValues.isEmpty()) { return null; } if (nonNegativeValues.size() > 1) { throw new ExpressionEvaluationException("Expression returned more than one value ("+nonNegativeValues.size()+") in "+shortDesc); } return nonNegativeValues.iterator().next().getValue(); }
public static <V extends PrismValue, D extends ItemDefinition> V evaluateExpression( ExpressionVariables variables, D outputDefinition, ExpressionType expressionType, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { Expression<V, D> expression = expressionFactory.makeExpression(expressionType, outputDefinition, shortDesc, task, parentResult); ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, variables, shortDesc, task, parentResult); PrismValueDeltaSetTriple<V> outputTriple = expression.evaluate(context); LOGGER.trace("Result of the expression evaluation: {}", outputTriple); return getExpressionOutputValue(outputTriple, shortDesc); }
private List<ObjectReferenceType> evaluateRefExpression(ExpressionType expressionType, ExpressionVariables expressionVariables, String shortDesc, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { QName resultName = new QName(SchemaConstants.NS_C, "result"); PrismReferenceDefinition resultDef = prismContext.definitionFactory().createReferenceDefinition(resultName, ObjectReferenceType.COMPLEX_TYPE); Expression<PrismReferenceValue,PrismReferenceDefinition> expression = expressionFactory.makeExpression(expressionType, resultDef, shortDesc, task, result); ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, expressionVariables, shortDesc, task, result); context.setAdditionalConvertor(ExpressionUtil.createRefConvertor(UserType.COMPLEX_TYPE)); PrismValueDeltaSetTriple<PrismReferenceValue> exprResult = ModelExpressionThreadLocalHolder.evaluateRefExpressionInContext(expression, context, task, result); List<ObjectReferenceType> retval = new ArrayList<>(); for (PrismReferenceValue value : exprResult.getZeroSet()) { ObjectReferenceType ort = new ObjectReferenceType(); ort.setupReferenceValue(value); retval.add(ort); } return retval; }
public static Collection<String> evaluateStringExpression(ExpressionVariables variables, PrismContext prismContext, ExpressionType expressionType, ExpressionFactory expressionFactory, String shortDesc, Task task, OperationResult parentResult) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { MutablePrismPropertyDefinition<String> outputDefinition = prismContext.definitionFactory().createPropertyDefinition( ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_STRING); outputDefinition.setMaxOccurs(-1); Expression<PrismPropertyValue<String>, PrismPropertyDefinition<String>> expression = expressionFactory .makeExpression(expressionType, outputDefinition, shortDesc, task, parentResult); ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, variables, shortDesc, task, parentResult); PrismValueDeltaSetTriple<PrismPropertyValue<String>> outputTriple = expression.evaluate(context); LOGGER.trace("Result of the expression evaluation: {}", outputTriple); if (outputTriple == null) { return null; } Collection<PrismPropertyValue<String>> nonNegativeValues = outputTriple.getNonNegativeValues(); if (nonNegativeValues == null || nonNegativeValues.isEmpty()) { return null; } return PrismValueCollectionsUtil.getRealValuesOfCollection((Collection) nonNegativeValues); // return nonNegativeValues.iterator().next(); }
private <O extends ObjectType> Collection<PrismValue> evaluateValueExpression(PrismObject<O> objectLeft, PrismObject<O> objectRight, String side, PrismValue origValue, Expression<PrismValue, ItemDefinition> valueExpression, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_SIDE, side); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT_LEFT, side); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT_RIGHT, side); variables.addVariableDefinition(ExpressionConstants.VAR_INPUT, origValue); variables.addVariableDefinition(ExpressionConstants.VAR_VALUE, origValue); ExpressionEvaluationContext exprContext = new ExpressionEvaluationContext(null, variables, "for value "+origValue, task, result); PrismValueDeltaSetTriple<PrismValue> triple = valueExpression.evaluate(exprContext); if (triple == null) { return null; } return triple.getNonNegativeValues(); }
private static Object variableFromOtherExpression(HashMap<String, Object> resultingVariables, ScriptingVariableDefinitionType definition, VariableResolutionContext ctx, String shortDesc, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException { ItemDefinition<?> outputDefinition = determineOutputDefinition(definition, ctx, shortDesc); Expression<PrismValue, ItemDefinition<?>> expression = ctx.expressionFactory .makeExpression(definition.getExpression(), outputDefinition, shortDesc, ctx.task, result); ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, createVariables(resultingVariables), shortDesc, ctx.task, result); PrismValueDeltaSetTriple<?> triple = ModelExpressionThreadLocalHolder .evaluateAnyExpressionInContext(expression, context, ctx.task, result); Collection<?> resultingValues = triple.getNonNegativeValues(); if (definition.getMaxOccurs() != null && outputDefinition.isSingleValue() // cardinality of outputDefinition is derived solely from definition.maxOccurs (if specified) || definition.getMaxOccurs() == null || resultingValues.size() <= 1) { return MiscUtil.getSingleValue(resultingValues, null, shortDesc); // unwrapping will occur when the value is used } else { return unwrapPrismValues(resultingValues); } }
private boolean evalCondition(Object value) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_INPUT, value); if (additionalVariableName != null) { variables.addVariableDefinition(additionalVariableName, value); } if (additionalVariables != null) { variables.addVariableDefinitions(additionalVariables, variables.keySet()); } ExpressionEvaluationContext context = new ExpressionEvaluationContext(null, variables, shortDesc, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple = condition.evaluate(context); if (outputTriple == null) { return false; } return ExpressionUtil.computeConditionResult(outputTriple.getNonNegativeValues()); }
private <F extends AssignmentHolderType> boolean shouldTransition(LensContext<F> context, LifecycleStateTransitionType transitionType, String targetLifecycleState, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionType conditionExpressionType = transitionType.getCondition(); if (conditionExpressionType == null) { return false; } String desc = "condition for transition to state "+targetLifecycleState+" for "+context.getFocusContext().getHumanReadableName(); ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_OBJECT, context.getFocusContext().getObjectNew()); // TODO: more variables? Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> expression = expressionFactory.makeExpression( conditionExpressionType, ExpressionUtil.createConditionOutputDefinition(context.getPrismContext()) , desc, task, result); ExpressionEvaluationContext expressionContext = new ExpressionEvaluationContext(null , variables, desc, task, result); ExpressionEnvironment<?> env = new ExpressionEnvironment<>(context, null, task, result); PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple = ModelExpressionThreadLocalHolder.evaluateExpressionInContext(expression, expressionContext, env); PrismPropertyValue<Boolean> expressionOutputValue = ExpressionUtil.getExpressionOutputValue(outputTriple, desc); return ExpressionUtil.getBooleanConditionOutput(expressionOutputValue); }
private void evaluateCondition(Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { ExpressionType conditionExpressionType = mappingType.getCondition(); if (conditionExpressionType == null) { // True -> True conditionOutputTriple = getPrismContext().deltaFactory().createPrismValueDeltaSetTriple(); conditionOutputTriple.addToZeroSet(getPrismContext().itemFactory().createPropertyValue(Boolean.TRUE)); return; } Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> expression = ExpressionUtil.createCondition(conditionExpressionType, expressionFactory, "condition in "+getMappingContextDescription(), task, result); ExpressionEvaluationContext context = new ExpressionEvaluationContext(sources, variables, "condition in "+getMappingContextDescription(), task, result); context.setValuePolicyResolver(stringPolicyResolver); context.setExpressionFactory(expressionFactory); context.setDefaultSource(defaultSource); context.setDefaultTargetContext(getTargetContext()); context.setRefinedObjectClassDefinition(getRefinedObjectClassDefinition()); context.setMappingQName(mappingQName); context.setVariableProducer(variableProducer); conditionOutputTriple = expression.evaluate(context); }
@Test public void testIterationCondition() throws Exception { final String TEST_NAME = "testIterationCondition"; TestUtil.displayTestTitle(TEST_NAME); // GIVEN OperationResult result = new OperationResult(TestExpression.class.getName()+"."+TEST_NAME); rememberScriptExecutionCount(); ExpressionType expressionType = PrismTestUtil.parseAtomicValue( EXPRESSION_ITERATION_CONDITION_FILE, ExpressionType.COMPLEX_TYPE); PrismPropertyDefinition<Boolean> outputDefinition = prismContext.definitionFactory().createPropertyDefinition( ExpressionConstants.OUTPUT_ELEMENT_NAME, DOMUtil.XSD_BOOLEAN); Expression<PrismPropertyValue<Boolean>,PrismPropertyDefinition<Boolean>> expression = expressionFactory.makeExpression(expressionType, outputDefinition , TEST_NAME, null, result); ExpressionVariables variables = new ExpressionVariables(); PrismObject<UserType> user = PrismTestUtil.parseObject(USER_JACK_FILE); variables.addVariableDefinition(ExpressionConstants.VAR_FOCUS, user); variables.addVariableDefinition(ExpressionConstants.VAR_USER, user); PrismObject<ShadowType> account = PrismTestUtil.parseObject(ACCOUNT_JACK_DUMMYFILE); variables.addVariableDefinition(ExpressionConstants.VAR_SHADOW, account); variables.addVariableDefinition(ExpressionConstants.VAR_ITERATION, 1); variables.addVariableDefinition(ExpressionConstants.VAR_ITERATION_TOKEN, "001"); ExpressionEvaluationContext expressionContext = new ExpressionEvaluationContext(null , variables, TEST_NAME, null, result); // WHEN PrismValueDeltaSetTriple<PrismPropertyValue<Boolean>> outputTriple = expression.evaluate(expressionContext); // THEN assertNotNull(outputTriple); outputTriple.checkConsistence(); // Make sure that the script is executed only once. There is no delta in the variables, no need to do it twice. assertScriptExecutionIncrement(1); }