This is an automated email from the ASF dual-hosted git repository.
yamer pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie-drools.git
The following commit(s) were added to refs/heads/main by this push:
new 1293f28c9b [Incubator-kie-issues#1820] Resolve "Missing Conditional
element" runtime exception during model execution (#6257)
1293f28c9b is described below
commit 1293f28c9b68e86af5295b0ab68cf8fe63ab5471
Author: AthiraHari77 <[email protected]>
AuthorDate: Thu Feb 20 14:42:13 2025 +0530
[Incubator-kie-issues#1820] Resolve "Missing Conditional element" runtime
exception during model execution (#6257)
* [incubator-kie-issues#1820] Fix runtime exception during dmn model
execution
* [incubator-kie-issues#1820] Update test cases
* [incubator-kie-issues#1820] Code refactoring
* [incubator-kie-issues#1820] Fix header for dmn file
* [incubator-kie-issues#1820] Fix test cases
* [incubator-kie-issues#1820] Implement recursive retrieval of node by id
* [incubator-kie-issues#1820] Code refactoring
* [incubator-kie-issues#1820] Fix review comments
* [incubator-kie-issues#1820] Fix test cases
---------
Co-authored-by: athira <[email protected]>
Co-authored-by: Gabriele-Cardosi <[email protected]>
---
.../kie/dmn/core/ast/DMNConditionalEvaluator.java | 92 +++++++++++----
.../dmn/core/compiler/DMNEvaluatorCompiler.java | 39 +++++--
.../dmn/core/ast/DMNConditionalEvaluatorTest.java | 75 +++++++-----
.../core/compiler/DMNEvaluatorCompilerTest.java | 130 +++++++++++++++++++--
.../core/impl/DMNRuntimeEventManagerUtilsTest.java | 47 ++++++++
.../valid_models/DMNv1_5/ConditionalEvent.dmn | 95 +++++++++++++++
6 files changed, 408 insertions(+), 70 deletions(-)
diff --git
a/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/ast/DMNConditionalEvaluator.java
b/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/ast/DMNConditionalEvaluator.java
index 2643c08b7c..2df62a1dc7 100644
---
a/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/ast/DMNConditionalEvaluator.java
+++
b/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/ast/DMNConditionalEvaluator.java
@@ -18,8 +18,11 @@
*/
package org.kie.dmn.core.ast;
-import java.util.HashMap;
import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
import org.kie.dmn.api.core.DMNMessage;
import org.kie.dmn.api.core.DMNResult;
@@ -31,36 +34,80 @@ import org.kie.dmn.core.impl.DMNResultImpl;
import org.kie.dmn.core.impl.DMNRuntimeEventManagerUtils;
import org.kie.dmn.core.util.Msg;
import org.kie.dmn.core.util.MsgUtil;
-import org.kie.dmn.model.api.Conditional;
import org.kie.dmn.model.api.DMNElement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DMNConditionalEvaluator implements DMNExpressionEvaluator {
+ public enum EvaluatorType {
+ IF( "if" ),
+ THEN( "then" ),
+ ELSE( "else" );
+
+ public final String value;
+
+ EvaluatorType(String value) {
+ this.value = value;
+ }
+ public String getValue() {
+ return value;
+ }
+ }
+
+ public static class EvaluatorIdentifier {
+ final String id;
+ final EvaluatorType type;
+
+ public EvaluatorIdentifier (String id, EvaluatorType type) {
+ this.id = id;
+ this.type = type;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == null || getClass() != o.getClass()) return false;
+ EvaluatorIdentifier that = (EvaluatorIdentifier) o;
+ return Objects.equals(id, that.id) && type == that.type;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(id, type);
+ }
+ }
+
private static final Logger logger =
LoggerFactory.getLogger(DMNConditionalEvaluator.class);
- private DMNExpressionEvaluator ifEvaluator;
- private DMNExpressionEvaluator thenEvaluator;
- private DMNExpressionEvaluator elseEvaluator;
- private DMNElement node;
- private String name;
- private final Map<DMNExpressionEvaluator, String> evaluatorIdMap = new
HashMap<>();
+ private final DMNExpressionEvaluator ifEvaluator;
+ private final DMNExpressionEvaluator thenEvaluator;
+ private final DMNExpressionEvaluator elseEvaluator;
+ private final DMNElement node;
+ private final String name;
+ private final EvaluatorIdentifier ifEvaluatorIdentifier;
+ private final EvaluatorIdentifier thenEvaluatorIdentifier;
+ private final EvaluatorIdentifier elseEvaluatorIdentifier;
- public DMNConditionalEvaluator(String name, DMNElement node,
DMNExpressionEvaluator ifEvaluator, DMNExpressionEvaluator thenEvaluator,
DMNExpressionEvaluator elseEvaluator) {
+ static Map<EvaluatorType, EvaluatorIdentifier>
mapEvaluatorIdentifiers(Map<EvaluatorIdentifier, DMNExpressionEvaluator>
evaluatorIdMap) {
+ return evaluatorIdMap.keySet().stream()
+ .collect(Collectors.toMap(identifier -> identifier.type,
Function.identity()));
+ }
+
+ static EvaluatorIdentifier getEvaluatorIdentifier(Map<EvaluatorType,
EvaluatorIdentifier> evaluatorIdentifierMap, EvaluatorType type) {
+ return Optional.ofNullable(evaluatorIdentifierMap.get(type))
+ .orElseThrow(() -> new RuntimeException("Missing " + type + "
evaluator in evaluatorIdMap"));
+ }
+
+ public DMNConditionalEvaluator(String name, DMNElement node, Map
<EvaluatorIdentifier, DMNExpressionEvaluator> evaluatorIdMap) {
this.name = name;
this.node = node;
- this.ifEvaluator = ifEvaluator;
- this.thenEvaluator = thenEvaluator;
- this.elseEvaluator = elseEvaluator;
- Conditional conditional = node.getChildren().stream()
- .filter(c -> c instanceof Conditional)
- .map(c -> (Conditional) c)
- .findFirst()
- .orElseThrow(() -> new RuntimeException("Missing Conditional
element inside " + node));
- evaluatorIdMap.put(ifEvaluator, conditional.getIf().getId());
- evaluatorIdMap.put(thenEvaluator, conditional.getThen().getId());
- evaluatorIdMap.put(elseEvaluator, conditional.getElse().getId());
+ Map<EvaluatorType, EvaluatorIdentifier> evaluatorIdentifierMap =
mapEvaluatorIdentifiers(evaluatorIdMap);
+ this.ifEvaluatorIdentifier =
getEvaluatorIdentifier(evaluatorIdentifierMap, EvaluatorType.IF);
+ this.thenEvaluatorIdentifier =
getEvaluatorIdentifier(evaluatorIdentifierMap, EvaluatorType.THEN);
+ this.elseEvaluatorIdentifier =
getEvaluatorIdentifier(evaluatorIdentifierMap, EvaluatorType.ELSE);
+ this.ifEvaluator = evaluatorIdMap.get(ifEvaluatorIdentifier);
+ this.thenEvaluator = evaluatorIdMap.get(thenEvaluatorIdentifier);
+ this.elseEvaluator = evaluatorIdMap.get(elseEvaluatorIdentifier);
}
@Override
@@ -68,7 +115,7 @@ public class DMNConditionalEvaluator implements
DMNExpressionEvaluator {
DMNResultImpl result = (DMNResultImpl) dmnr;
EvaluatorResult ifEvaluation = ifEvaluator.evaluate(eventManager,
result);
- String executedId = evaluatorIdMap.get(ifEvaluator);
+ String executedId = ifEvaluatorIdentifier.id;
DMNRuntimeEventManagerUtils.fireAfterEvaluateConditional(eventManager,
ifEvaluation, executedId);
if (ifEvaluation.getResultType().equals(ResultType.SUCCESS)) {
Object ifResult = ifEvaluation.getResult();
@@ -92,9 +139,8 @@ public class DMNConditionalEvaluator implements
DMNExpressionEvaluator {
protected EvaluatorResult manageBooleanOrNullIfResult(Boolean
booleanResult, DMNRuntimeEventManager eventManager, DMNResultImpl result) {
DMNExpressionEvaluator evaluatorToUse = booleanResult != null &&
booleanResult ? thenEvaluator : elseEvaluator;
-
EvaluatorResult toReturn = evaluatorToUse.evaluate(eventManager,
result);
- String executedId = evaluatorIdMap.get(evaluatorToUse);
+ String executedId = evaluatorToUse.equals(thenEvaluator) ?
thenEvaluatorIdentifier.id : elseEvaluatorIdentifier.id;
DMNRuntimeEventManagerUtils.fireAfterConditionalEvaluation(eventManager, name,
toReturn, executedId);
return toReturn;
}
diff --git
a/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/compiler/DMNEvaluatorCompiler.java
b/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/compiler/DMNEvaluatorCompiler.java
index ee224cf2c1..72d636056a 100644
---
a/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/compiler/DMNEvaluatorCompiler.java
+++
b/kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/compiler/DMNEvaluatorCompiler.java
@@ -22,14 +22,15 @@ import static java.util.stream.Collectors.toList;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;
-import javax.swing.DefaultListSelectionModel;
import javax.xml.namespace.QName;
import org.kie.api.io.Resource;
@@ -124,6 +125,18 @@ public class DMNEvaluatorCompiler implements
DMNDecisionLogicCompiler {
}
}
+ static Map<DMNConditionalEvaluator.EvaluatorIdentifier,
DMNExpressionEvaluator> getEvaluatorIdentifierMap(Conditional expression,
DMNExpressionEvaluator ifEvaluator, DMNExpressionEvaluator thenEvaluator,
DMNExpressionEvaluator elseEvaluator) {
+ Map<DMNConditionalEvaluator.EvaluatorIdentifier,
DMNExpressionEvaluator> evaluatorIdMap = new HashMap<>();
+ evaluatorIdMap.put(getEvaluatorIdentifier(expression.getIf().getId(),
DMNConditionalEvaluator.EvaluatorType.IF), ifEvaluator);
+
evaluatorIdMap.put(getEvaluatorIdentifier(expression.getThen().getId(),
DMNConditionalEvaluator.EvaluatorType.THEN), thenEvaluator);
+
evaluatorIdMap.put(getEvaluatorIdentifier(expression.getElse().getId(),
DMNConditionalEvaluator.EvaluatorType.ELSE), elseEvaluator);
+ return evaluatorIdMap;
+ }
+
+ static DMNConditionalEvaluator.EvaluatorIdentifier
getEvaluatorIdentifier(String id, DMNConditionalEvaluator.EvaluatorType type) {
+ return new DMNConditionalEvaluator.EvaluatorIdentifier(id, type);
+ }
+
@Override
public DMNExpressionEvaluator compileExpression(DMNCompilerContext ctx,
DMNModelImpl model, DMNBaseNode node,
String exprName,
Expression expression) {
@@ -1035,37 +1048,39 @@ public class DMNEvaluatorCompiler implements
DMNDecisionLogicCompiler {
return ctx.getFeelHelper().evaluateUnaryTests(ctx, text, model,
element, errorMsg, msgParams);
}
- private DMNExpressionEvaluator compileConditional(DMNCompilerContext ctx,
DMNModelImpl model, DMNBaseNode node,
- String exprName,
Conditional expression) {
- DMNExpressionEvaluator ifEvaluator = compileExpression(ctx, model,
node, exprName + " [if]",
+ protected DMNExpressionEvaluator compileConditional(DMNCompilerContext
ctx, DMNModelImpl model, DMNBaseNode node,
+ String exprName, Conditional
expression) {
+ DMNExpressionEvaluator ifEvaluator = compileExpression(ctx, model,
node, formatExpressionName(exprName, DMNConditionalEvaluator.EvaluatorType.IF),
expression.getIf().getExpression());
- DMNExpressionEvaluator thenEvaluator = compileExpression(ctx, model,
node, exprName + " [then]",
+ DMNExpressionEvaluator thenEvaluator = compileExpression(ctx, model,
node, formatExpressionName(exprName,
DMNConditionalEvaluator.EvaluatorType.THEN),
expression.getThen().getExpression());
- DMNExpressionEvaluator elseEvaluator = compileExpression(ctx, model,
node, exprName + " [else]",
+ DMNExpressionEvaluator elseEvaluator = compileExpression(ctx, model,
node, formatExpressionName(exprName,
DMNConditionalEvaluator.EvaluatorType.ELSE),
expression.getElse().getExpression());
if (ifEvaluator == null) {
MsgUtil.reportMessage(logger, DMNMessage.Severity.ERROR,
node.getSource(), model, null, null,
- Msg.MISSING_EXPRESSION_FOR_CONDITION, "if",
+ Msg.MISSING_EXPRESSION_FOR_CONDITION,
DMNConditionalEvaluator.EvaluatorType.IF.getValue(),
node.getIdentifierString());
return null;
}
if (thenEvaluator == null) {
MsgUtil.reportMessage(logger, DMNMessage.Severity.ERROR,
node.getSource(), model, null, null,
- Msg.MISSING_EXPRESSION_FOR_CONDITION, "then",
+ Msg.MISSING_EXPRESSION_FOR_CONDITION,
DMNConditionalEvaluator.EvaluatorType.THEN.getValue(),
node.getIdentifierString());
return null;
}
if (elseEvaluator == null) {
MsgUtil.reportMessage(logger, DMNMessage.Severity.ERROR,
node.getSource(), model, null, null,
- Msg.MISSING_EXPRESSION_FOR_CONDITION, "else",
+ Msg.MISSING_EXPRESSION_FOR_CONDITION,
DMNConditionalEvaluator.EvaluatorType.ELSE.getValue(),
node.getIdentifierString());
return null;
}
- return new DMNConditionalEvaluator(exprName, node.getSource(),
ifEvaluator, thenEvaluator, elseEvaluator);
+ Map<DMNConditionalEvaluator.EvaluatorIdentifier,
DMNExpressionEvaluator> evaluatorIdMap = getEvaluatorIdentifierMap(expression,
ifEvaluator, thenEvaluator, elseEvaluator);
+
+ return new DMNConditionalEvaluator(exprName, node.getSource(),
evaluatorIdMap);
}
private DMNExpressionEvaluator compileIterator(DMNCompilerContext ctx,
DMNModelImpl model, DMNBaseNode node,
@@ -1180,4 +1195,8 @@ public class DMNEvaluatorCompiler implements
DMNDecisionLogicCompiler {
return new DMNFilterEvaluator(exprName, node.getSource(), inEvaluator,
filterEvaluator);
}
+
+ private static String formatExpressionName(String exprName,
DMNConditionalEvaluator.EvaluatorType type) {
+ return String.format("%s [%s]", exprName, type.getValue());
+ }
}
diff --git
a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/ast/DMNConditionalEvaluatorTest.java
b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/ast/DMNConditionalEvaluatorTest.java
index 4514ce77ce..881df88463 100644
---
a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/ast/DMNConditionalEvaluatorTest.java
+++
b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/ast/DMNConditionalEvaluatorTest.java
@@ -19,7 +19,8 @@
package org.kie.dmn.core.ast;
import java.util.Collections;
-import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
import java.util.Set;
import org.junit.jupiter.api.BeforeAll;
@@ -32,14 +33,11 @@ import org.kie.dmn.api.core.event.DMNRuntimeEventListener;
import org.kie.dmn.api.core.event.DMNRuntimeEventManager;
import org.kie.dmn.core.api.DMNExpressionEvaluator;
import org.kie.dmn.core.impl.DMNResultImpl;
-import org.kie.dmn.model.api.ChildExpression;
-import org.kie.dmn.model.api.Conditional;
import org.kie.dmn.model.api.DMNElement;
-import org.kie.dmn.model.api.DMNModelInstrumentedBase;
-import org.kie.dmn.model.api.Expression;
import org.mockito.ArgumentCaptor;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatRuntimeException;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
@@ -48,16 +46,20 @@ import static org.mockito.Mockito.when;
class DMNConditionalEvaluatorTest {
- private static final String ID_ELEMENT_ID = "ID_ELEMENT_ID";
+ private static final String IF_ELEMENT_ID = "IF_ELEMENT_ID";
private static final String THEN_ELEMENT_ID = "THEN_ELEMENT_ID";
private static final String ELSE_ELEMENT_ID = "ELSE_ELEMENT_ID";
+ private static final Map<DMNConditionalEvaluator.EvaluatorIdentifier,
DMNExpressionEvaluator> EVALUATOR_ID_MAP = new HashMap<>();
+ private static DMNConditionalEvaluator dmnConditionalEvaluator;
+ private static DMNConditionalEvaluator.EvaluatorIdentifier ifIdentifier;
+ private static DMNConditionalEvaluator.EvaluatorIdentifier thenIdentifier;
+ private static DMNConditionalEvaluator.EvaluatorIdentifier elseIdentifier;
private static DMNRuntimeEventManager eventManagerMock;
private static DMNRuntimeEventListener spiedListener;
+ private static DMNResultImpl dmnResultMock;
private static EvaluatorResult ifEvaluationMock;
private static EvaluatorResult thenEvaluationMock;
private static EvaluatorResult elseEvaluationMock;
- private static DMNResultImpl dmnResultMock;
- private static DMNConditionalEvaluator dmnConditionalEvaluator;
@BeforeAll
static void setUp() {
@@ -79,29 +81,17 @@ class DMNConditionalEvaluatorTest {
when(thenEvaluatorMock.evaluate(eventManagerMock,
dmnResultMock)).thenReturn(thenEvaluationMock);
when(elseEvaluatorMock.evaluate(eventManagerMock,
dmnResultMock)).thenReturn(elseEvaluationMock);
- ChildExpression ifMock = mock(ChildExpression.class);
- when(ifMock.getId()).thenReturn(ID_ELEMENT_ID);
-
- ChildExpression thenMock = mock(ChildExpression.class);
- when(thenMock.getId()).thenReturn(THEN_ELEMENT_ID);
-
- ChildExpression elseMock = mock(ChildExpression.class);
- when(elseMock.getId()).thenReturn(ELSE_ELEMENT_ID);
+ DMNElement nodeMock = mock(DMNElement.class);
- Conditional conditionalMock = mock(Conditional.class);
- when(conditionalMock.getIf()).thenReturn(ifMock);
- when(conditionalMock.getThen()).thenReturn(thenMock);
- when(conditionalMock.getElse()).thenReturn(elseMock);
+ ifIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier(IF_ELEMENT_ID,
DMNConditionalEvaluator.EvaluatorType.IF);
+ thenIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier(THEN_ELEMENT_ID,
DMNConditionalEvaluator.EvaluatorType.THEN);
+ elseIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier(ELSE_ELEMENT_ID,
DMNConditionalEvaluator.EvaluatorType.ELSE);
- List<DMNModelInstrumentedBase> nodeChildren =
Collections.singletonList(conditionalMock);
- DMNElement nodeMock = mock(DMNElement.class);
- when(nodeMock.getChildren()).thenReturn(nodeChildren);
+ EVALUATOR_ID_MAP.put(ifIdentifier, ifEvaluatorMock);
+ EVALUATOR_ID_MAP.put(thenIdentifier, thenEvaluatorMock);
+ EVALUATOR_ID_MAP.put(elseIdentifier, elseEvaluatorMock);
- dmnConditionalEvaluator = new DMNConditionalEvaluator("name",
- nodeMock,
- ifEvaluatorMock,
-
thenEvaluatorMock,
-
elseEvaluatorMock);
+ dmnConditionalEvaluator = new DMNConditionalEvaluator("name",
nodeMock, EVALUATOR_ID_MAP);
}
@BeforeEach
@@ -121,7 +111,7 @@ class DMNConditionalEvaluatorTest {
AfterEvaluateConditionalEvent evaluateConditionalEvent =
evaluateConditionalEventArgumentCaptor.getValue();
assertThat(evaluateConditionalEvent).isNotNull();
assertThat(evaluateConditionalEvent.getEvaluatorResultResult()).isEqualTo(ifEvaluationMock);
-
assertThat(evaluateConditionalEvent.getExecutedId()).isEqualTo(ID_ELEMENT_ID);
+
assertThat(evaluateConditionalEvent.getExecutedId()).isEqualTo(IF_ELEMENT_ID);
}
@Test
@@ -172,4 +162,31 @@ class DMNConditionalEvaluatorTest {
assertThat(conditionalEvaluationEvent.getEvaluatorResultResult()).isEqualTo(elseEvaluationMock);
assertThat(conditionalEvaluationEvent.getExecutedId()).isEqualTo(ELSE_ELEMENT_ID);
}
+
+ @Test
+ void testMapEvaluatorIdentifiers() {
+ Map<DMNConditionalEvaluator.EvaluatorType,
DMNConditionalEvaluator.EvaluatorIdentifier> mapEvaluatorIdentifiers =
DMNConditionalEvaluator.mapEvaluatorIdentifiers(EVALUATOR_ID_MAP);
+
+
assertThat(mapEvaluatorIdentifiers.get(DMNConditionalEvaluator.EvaluatorType.IF)).isEqualTo(ifIdentifier);
+
assertThat(mapEvaluatorIdentifiers.get(DMNConditionalEvaluator.EvaluatorType.THEN)).isEqualTo(thenIdentifier);
+
assertThat(mapEvaluatorIdentifiers.get(DMNConditionalEvaluator.EvaluatorType.ELSE)).isEqualTo(elseIdentifier);
+ }
+
+ @Test
+ void testGetEvaluatorIdentifier() {
+ Map<DMNConditionalEvaluator.EvaluatorType,
DMNConditionalEvaluator.EvaluatorIdentifier> evaluatorIdentifierMap = Map.of(
+ DMNConditionalEvaluator.EvaluatorType.IF, ifIdentifier,
+ DMNConditionalEvaluator.EvaluatorType.THEN, thenIdentifier,
+ DMNConditionalEvaluator.EvaluatorType.ELSE, elseIdentifier);
+ for (DMNConditionalEvaluator.EvaluatorType type :
DMNConditionalEvaluator.EvaluatorType.values()) {
+
assertThat(DMNConditionalEvaluator.getEvaluatorIdentifier(evaluatorIdentifierMap,
type)).isEqualTo(evaluatorIdentifierMap.get(type));
+ }
+ }
+
+ @Test
+ void testMissingEvaluatorIdentifier() {
+ Map<DMNConditionalEvaluator.EvaluatorType,
DMNConditionalEvaluator.EvaluatorIdentifier> evaluatorIdentifierMap = new
HashMap<>();
+ String errorMessage = "Missing THEN evaluator in evaluatorIdMap";
+ assertThatRuntimeException().isThrownBy(() ->
DMNConditionalEvaluator.getEvaluatorIdentifier(evaluatorIdentifierMap,
DMNConditionalEvaluator.EvaluatorType.THEN)).withMessage(errorMessage);
+ }
}
\ No newline at end of file
diff --git
a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/DMNEvaluatorCompilerTest.java
b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/DMNEvaluatorCompilerTest.java
index c7fc079d11..d316b3bea3 100644
---
a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/DMNEvaluatorCompilerTest.java
+++
b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/compiler/DMNEvaluatorCompilerTest.java
@@ -19,56 +19,81 @@
package org.kie.dmn.core.compiler;
import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
+import org.kie.api.io.Resource;
+import org.kie.dmn.api.core.DMNModel;
+import org.kie.dmn.api.core.DMNRuntime;
+import org.kie.dmn.api.core.DMNType;
+import org.kie.dmn.core.api.DMNExpressionEvaluator;
+import org.kie.dmn.core.ast.DMNBaseNode;
+import org.kie.dmn.core.ast.DMNConditionalEvaluator;
+import org.kie.dmn.core.impl.DMNModelImpl;
+import org.kie.dmn.core.internal.utils.DMNRuntimeBuilder;
import org.kie.dmn.feel.FEEL;
import org.kie.dmn.feel.lang.FEELDialect;
import org.kie.dmn.feel.lang.impl.FEELImpl;
+import org.kie.dmn.model.api.Conditional;
+import org.kie.dmn.model.api.DMNModelInstrumentedBase;
import org.kie.dmn.model.api.LiteralExpression;
import org.kie.dmn.model.v1_5.TLiteralExpression;
+import org.kie.internal.io.ResourceFactory;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.kie.dmn.core.ast.DMNConditionalEvaluator.EvaluatorType.ELSE;
+import static org.kie.dmn.core.ast.DMNConditionalEvaluator.EvaluatorType.IF;
+import static org.kie.dmn.core.ast.DMNConditionalEvaluator.EvaluatorType.THEN;
+import static
org.kie.dmn.core.compiler.DMNEvaluatorCompiler.getEvaluatorIdentifier;
+import static
org.kie.dmn.core.compiler.DMNEvaluatorCompiler.getEvaluatorIdentifierMap;
class DMNEvaluatorCompilerTest {
private static final FEELDialect DEFAULT_FEEL_DIALECT = FEELDialect.FEEL;
- private static DMNFEELHelper DMN_FEEL_HELPER;
+ private static final String IF_ELEMENT_ID = "IF_ELEMENT_ID";
+ private static final String THEN_ELEMENT_ID = "THEN_ELEMENT_ID";
+ private static final String ELSE_ELEMENT_ID = "ELSE_ELEMENT_ID";
private static DMNCompilerContext DMN_COMPILER_CONTEXT;
+ private static DMNEvaluatorCompiler dmnEvaluatorCompiler;
+ private static DMNFEELHelper DMN_FEEL_HELPER;
@BeforeAll
static void setUp() {
DMN_FEEL_HELPER = new DMNFEELHelper(Collections.emptyList(),
DEFAULT_FEEL_DIALECT);
DMN_COMPILER_CONTEXT = new DMNCompilerContext(DMN_FEEL_HELPER);
+
+ DMNCompilerImpl compiler = new DMNCompilerImpl();
+ dmnEvaluatorCompiler = new DMNEvaluatorCompiler(compiler);
}
@Test
void getFEELDialectAdaptedFEELNoExpressionLanguage() {
String expressionLanguage = null;
LiteralExpression expression =
getLiteralExpression(expressionLanguage);
- FEEL retrieved =
DMNEvaluatorCompiler.getFEELDialectAdaptedFEEL(DMN_COMPILER_CONTEXT,
expression, expressionLanguage);
+ FEEL retrieved =
DMNEvaluatorCompiler.getFEELDialectAdaptedFEEL(DMN_COMPILER_CONTEXT,
expression, expressionLanguage);
assertThat(retrieved).isNotNull().isInstanceOf(FEELImpl.class);
-
assertThat(((FEELImpl)retrieved).getFeelDialect()).isEqualTo(DEFAULT_FEEL_DIALECT);
+ assertThat(((FEELImpl)
retrieved).getFeelDialect()).isEqualTo(DEFAULT_FEEL_DIALECT);
}
@Test
void getFEELDialectAdaptedFEELFEELURIExpressionLanguage() {
LiteralExpression expression = getLiteralExpression(null);
String expressionLanguage = expression.getURIFEEL();
- FEEL retrieved =
DMNEvaluatorCompiler.getFEELDialectAdaptedFEEL(DMN_COMPILER_CONTEXT,
expression, expressionLanguage);
+ FEEL retrieved =
DMNEvaluatorCompiler.getFEELDialectAdaptedFEEL(DMN_COMPILER_CONTEXT,
expression, expressionLanguage);
assertThat(retrieved).isNotNull().isInstanceOf(FEELImpl.class);
-
assertThat(((FEELImpl)retrieved).getFeelDialect()).isEqualTo(DEFAULT_FEEL_DIALECT);
+ assertThat(((FEELImpl)
retrieved).getFeelDialect()).isEqualTo(DEFAULT_FEEL_DIALECT);
}
@Test
void getFEELDialectAdaptedFEELBFEELExpressionLanguage() {
String expressionLanguage = FEELDialect.BFEEL.getNamespace();
LiteralExpression expression =
getLiteralExpression(expressionLanguage);
- FEEL retrieved =
DMNEvaluatorCompiler.getFEELDialectAdaptedFEEL(DMN_COMPILER_CONTEXT,
expression, expressionLanguage);
+ FEEL retrieved =
DMNEvaluatorCompiler.getFEELDialectAdaptedFEEL(DMN_COMPILER_CONTEXT,
expression, expressionLanguage);
assertThat(retrieved).isNotNull().isInstanceOf(FEELImpl.class);
-
assertThat(((FEELImpl)retrieved).getFeelDialect()).isEqualTo(FEELDialect.BFEEL);
+ assertThat(((FEELImpl)
retrieved).getFeelDialect()).isEqualTo(FEELDialect.BFEEL);
}
@Test
@@ -81,10 +106,99 @@ class DMNEvaluatorCompilerTest {
.hasMessage(expectedMessage);
}
+ @Test
+ void testGetEvaluatorIdentifierMap() {
+ String ifExprName = "testExpression [if]" ;
+ String thenExprName = "testExpression [then]";
+ String elseExprName = "testExpression [else]";
+ DMNConditionalEvaluator.EvaluatorIdentifier ifIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier("_96D34F2E-3CC0-45A6-9455-2F960361A9CC",
DMNConditionalEvaluator.EvaluatorType.IF);
+ DMNConditionalEvaluator.EvaluatorIdentifier thenIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier("_F9D2FA33-4604-4AAA-8FF1-5A4AC5055385",
DMNConditionalEvaluator.EvaluatorType.THEN);
+ DMNConditionalEvaluator.EvaluatorIdentifier elseIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier("_7C843AB8-961C-4A95-83B3-2D1593DF297C",
DMNConditionalEvaluator.EvaluatorType.ELSE);
+
+ Resource resource =
ResourceFactory.newClassPathResource("valid_models/DMNv1_5/ConditionalEvent.dmn");
+ DMNRuntime dmnRuntime =
DMNRuntimeBuilder.fromDefaults().buildConfiguration()
+
.fromResources(Collections.singletonList(resource)).getOrElseThrow(RuntimeException::new);
+ assertThat(dmnRuntime).isNotNull();
+ String nameSpace =
"https://kie.org/dmn/_5B448C78-0DBF-4554-92A4-8C0247EB01FD";;
+
+ final DMNModel dmnModel = dmnRuntime.getModel(nameSpace,
"DMN_00DF4B93-0243-4813-BA70-A1894AC723BE");
+ assertThat(dmnModel).isNotNull();
+ DMNModelInstrumentedBase retrieved = getNodeById(dmnModel,
"_096DC616-A4D5-449C-A350-491E42F3C8FB");
+ assertThat(retrieved).isNotNull();
+ Conditional expr = (Conditional) retrieved;
+ DMNBaseNode dmnBaseNode = getNodeByName(dmnModel, "B");
+ DMNType numType = dmnBaseNode.getType();
+ DMNCompilerContext compilerContext = new
DMNCompilerContext(DMN_FEEL_HELPER);;
+ compilerContext.setVariable("num", numType);
+ DMNExpressionEvaluator ifEvaluator =
dmnEvaluatorCompiler.compileExpression(compilerContext, (DMNModelImpl)
dmnModel, dmnBaseNode, ifExprName, expr.getIf().getExpression());
+ DMNExpressionEvaluator thenEvaluator =
dmnEvaluatorCompiler.compileExpression(compilerContext, (DMNModelImpl)
dmnModel, dmnBaseNode, thenExprName, expr.getThen().getExpression());
+ DMNExpressionEvaluator elseEvaluator =
dmnEvaluatorCompiler.compileExpression(compilerContext, (DMNModelImpl)
dmnModel, dmnBaseNode, elseExprName, expr.getElse().getExpression());
+
+ Map<DMNConditionalEvaluator.EvaluatorIdentifier,
DMNExpressionEvaluator> result = getEvaluatorIdentifierMap(expr, ifEvaluator,
thenEvaluator, elseEvaluator);
+ assertThat(result).hasSize(3);
+ assertThat(result.get(ifIdentifier)).isEqualTo(ifEvaluator);
+ assertThat(result.get(thenIdentifier)).isEqualTo(thenEvaluator);
+ assertThat(result.get(elseIdentifier)).isEqualTo(elseEvaluator);
+ }
+
+ @Test
+ void testGetEvaluatorIdentifier() {
+ DMNConditionalEvaluator.EvaluatorIdentifier ifIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier(IF_ELEMENT_ID, IF);
+ DMNConditionalEvaluator.EvaluatorIdentifier thenIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier(THEN_ELEMENT_ID, THEN);
+ DMNConditionalEvaluator.EvaluatorIdentifier elseIdentifier = new
DMNConditionalEvaluator.EvaluatorIdentifier(ELSE_ELEMENT_ID, ELSE);
+ DMNConditionalEvaluator.EvaluatorIdentifier ifEvaluatorIdentifier =
getEvaluatorIdentifier(IF_ELEMENT_ID, IF);
+ DMNConditionalEvaluator.EvaluatorIdentifier thenEvaluatorIdentifier =
getEvaluatorIdentifier(THEN_ELEMENT_ID, THEN);
+ DMNConditionalEvaluator.EvaluatorIdentifier elseEvaluatorIdentifier =
getEvaluatorIdentifier(ELSE_ELEMENT_ID, ELSE);
+
+ assertThat(ifEvaluatorIdentifier).isEqualTo(ifIdentifier);
+ assertThat(thenEvaluatorIdentifier).isEqualTo(thenIdentifier);
+ assertThat(elseEvaluatorIdentifier).isEqualTo(elseIdentifier);
+ }
+
+ @Test
+ void testCompileConditional() {
+ String exprName = "testExpression";
+ Resource resource =
ResourceFactory.newClassPathResource("valid_models/DMNv1_5/ConditionalEvent.dmn");
+ DMNRuntime dmnRuntime =
DMNRuntimeBuilder.fromDefaults().buildConfiguration()
+
.fromResources(Collections.singletonList(resource)).getOrElseThrow(RuntimeException::new);
+ assertThat(dmnRuntime).isNotNull();
+ String nameSpace =
"https://kie.org/dmn/_5B448C78-0DBF-4554-92A4-8C0247EB01FD";;
+
+ final DMNModel dmnModel = dmnRuntime.getModel(nameSpace,
"DMN_00DF4B93-0243-4813-BA70-A1894AC723BE");
+ assertThat(dmnModel).isNotNull();
+ DMNModelInstrumentedBase retrieved = getNodeById(dmnModel,
"_096DC616-A4D5-449C-A350-491E42F3C8FB");
+ assertThat(retrieved).isNotNull();
+ DMNBaseNode dmnBaseNode = getNodeByName(dmnModel, "B");
+ DMNType numType = dmnBaseNode.getType();
+ DMNCompilerContext compilerContext = new
DMNCompilerContext(DMN_FEEL_HELPER);
+ compilerContext.setVariable("num", numType);
+ DMNExpressionEvaluator result =
dmnEvaluatorCompiler.compileConditional(compilerContext, (DMNModelImpl)
dmnModel, dmnBaseNode, exprName, (Conditional) retrieved);
+ assertThat(result).isNotNull();
+ assertThat(result).isInstanceOf(DMNConditionalEvaluator.class);
+ }
+
private LiteralExpression getLiteralExpression(String expressionLanguage) {
LiteralExpression toReturn = new TLiteralExpression();
toReturn.setExpressionLanguage(expressionLanguage);
return toReturn;
}
+ private DMNModelInstrumentedBase getNodeById(DMNModel dmnModel, String id)
{
+ return dmnModel.getDefinitions().getChildren().stream().map(child ->
getNodeById(child, id))
+ .filter(Objects::nonNull).findFirst().orElse(null);
+ }
+
+ private DMNModelInstrumentedBase getNodeById(DMNModelInstrumentedBase
dmnModelInstrumentedBase, String id) {
+ if (dmnModelInstrumentedBase.getIdentifierString().equals(id)) {
+ return dmnModelInstrumentedBase;
+ }
+ return dmnModelInstrumentedBase.getChildren().stream().map(child ->
getNodeById(child, id))
+ .filter(Objects::nonNull).findFirst().orElse(null);
+ }
+
+ private DMNBaseNode getNodeByName(DMNModel dmnModel, String nodeName) {
+ return (DMNBaseNode) dmnModel.getDecisions().stream()
+ .filter(node -> node.getName().equals(nodeName))
+ .findFirst().orElse(null);
+ }
}
\ No newline at end of file
diff --git
a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNRuntimeEventManagerUtilsTest.java
b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNRuntimeEventManagerUtilsTest.java
index f99087d5c2..354ef23002 100644
---
a/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNRuntimeEventManagerUtilsTest.java
+++
b/kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/impl/DMNRuntimeEventManagerUtilsTest.java
@@ -19,19 +19,30 @@
package org.kie.dmn.core.impl;
import java.util.Collections;
+import java.util.List;
import java.util.Set;
import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.kie.api.io.Resource;
+import org.kie.dmn.api.core.DMNContext;
+import org.kie.dmn.api.core.DMNModel;
+import org.kie.dmn.api.core.DMNResult;
+import org.kie.dmn.api.core.DMNRuntime;
import org.kie.dmn.api.core.EvaluatorResult;
import org.kie.dmn.api.core.event.AfterConditionalEvaluationEvent;
import org.kie.dmn.api.core.event.AfterEvaluateConditionalEvent;
import org.kie.dmn.api.core.event.DMNRuntimeEventListener;
import org.kie.dmn.api.core.event.DMNRuntimeEventManager;
+import org.kie.dmn.core.api.DMNFactory;
+import org.kie.dmn.core.internal.utils.DMNRuntimeBuilder;
+import org.kie.internal.io.ResourceFactory;
import org.mockito.ArgumentCaptor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -50,6 +61,11 @@ class DMNRuntimeEventManagerUtilsTest {
when(eventManagerMock.getListeners()).thenReturn(listeners);
}
+ @BeforeEach
+ void setup() {
+ reset(spiedListener);
+ }
+
@Test
void fireAfterEvaluateConditional() {
EvaluatorResult evaluatorResult = mock(EvaluatorResult.class);
@@ -77,4 +93,35 @@ class DMNRuntimeEventManagerUtilsTest {
assertThat(evaluateConditionalEvent.getEvaluatorResultResult()).isEqualTo(evaluatorResult);
assertThat(evaluateConditionalEvent.getExecutedId()).isEqualTo(executedId);
}
+
+ @Test
+ void testConditionalEvent() {
+ EvaluatorResult evaluatorResult = mock(EvaluatorResult.class);
+ String name = "B [return]";
+ String executedId = "_96D34F2E-3CC0-45A6-9455-2F960361A9CC";
+ Resource resource =
ResourceFactory.newClassPathResource("valid_models/DMNv1_5/ConditionalEvent.dmn");
+ DMNRuntime dmnRuntime =
DMNRuntimeBuilder.fromDefaults().buildConfiguration()
+
.fromResources(Collections.singletonList(resource)).getOrElseThrow(RuntimeException::new);
+ assertThat(dmnRuntime).isNotNull();
+ String nameSpace =
"https://kie.org/dmn/_5B448C78-0DBF-4554-92A4-8C0247EB01FD";;
+
+ final DMNModel dmnModel = dmnRuntime.getModel(nameSpace,
"DMN_00DF4B93-0243-4813-BA70-A1894AC723BE");
+ assertThat(dmnModel).isNotNull();
+ DMNContext context = DMNFactory.newContext();
+ context.set("A", List.of(3));
+ DMNResult dmnResult = dmnRuntime.evaluateAll(dmnModel, context);
+
assertThat(dmnResult.getDecisionResultByName("B").getResult()).isEqualTo(List.of("pos"));
+
+ DMNRuntimeEventManager eventManager = new DMNRuntimeEventManagerImpl();
+ eventManager.addListener(spiedListener);
+
+
DMNRuntimeEventManagerUtils.fireAfterConditionalEvaluation(eventManager, name,
evaluatorResult, executedId);
+ ArgumentCaptor<AfterConditionalEvaluationEvent>
conditionalEvaluationEventArgumentCaptor =
ArgumentCaptor.forClass(AfterConditionalEvaluationEvent.class);
+ verify(spiedListener).afterConditionalEvaluation
(conditionalEvaluationEventArgumentCaptor.capture());
+ AfterConditionalEvaluationEvent evaluateConditionalEvent =
conditionalEvaluationEventArgumentCaptor.getValue();
+ assertThat(evaluateConditionalEvent).isNotNull();
+ assertThat(evaluateConditionalEvent.getNodeName()).isEqualTo(name);
+
assertThat(evaluateConditionalEvent.getEvaluatorResultResult()).isEqualTo(evaluatorResult);
+
assertThat(evaluateConditionalEvent.getExecutedId()).isEqualTo(executedId);
+ }
}
\ No newline at end of file
diff --git
a/kie-dmn/kie-dmn-test-resources/src/test/resources/valid_models/DMNv1_5/ConditionalEvent.dmn
b/kie-dmn/kie-dmn-test-resources/src/test/resources/valid_models/DMNv1_5/ConditionalEvent.dmn
new file mode 100644
index 0000000000..0c1ac72f20
--- /dev/null
+++
b/kie-dmn/kie-dmn-test-resources/src/test/resources/valid_models/DMNv1_5/ConditionalEvent.dmn
@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one
+ ~ or more contributor license agreements. See the NOTICE file
+ ~ distributed with this work for additional information
+ ~ regarding copyright ownership. The ASF licenses this file
+ ~ to you under the Apache License, Version 2.0 (the
+ ~ "License"); you may not use this file except in compliance
+ ~ with the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing,
+ ~ software distributed under the License is distributed on an
+ ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ ~ KIND, either express or implied. See the License for the
+ ~ specific language governing permissions and limitations
+ ~ under the License.
+-->
+<definitions xmlns="https://www.omg.org/spec/DMN/20230324/MODEL/";
xmlns:dmndi="https://www.omg.org/spec/DMN/20230324/DMNDI/";
xmlns:dc="http://www.omg.org/spec/DMN/20180521/DC/";
xmlns:di="http://www.omg.org/spec/DMN/20180521/DI/";
xmlns:kie="https://kie.org/dmn/extensions/1.0";
expressionLanguage="https://www.omg.org/spec/DMN/20230324/FEEL/";
namespace="https://kie.org/dmn/_5B448C78-0DBF-4554-92A4-8C0247EB01FD";
id="_FE1E1849-C3F7-4495-B255-10F416DCFA32"
name="DMN_00DF4B93-0243-4813-BA70-A189 [...]
+ <itemDefinition id="_FE51393E-A157-43DB-9AB2-A7645919001A" name="tStrings"
isCollection="true" typeLanguage="https://www.omg.org/spec/DMN/20230324/FEEL/";>
+ <typeRef>string</typeRef>
+ </itemDefinition>
+ <itemDefinition id="_928ECD2C-DB90-496B-A488-ABD056904135" name="tNumbers"
isCollection="true" typeLanguage="https://www.omg.org/spec/DMN/20230324/FEEL/";>
+ <typeRef>number</typeRef>
+ </itemDefinition>
+ <inputData name="A" id="_6A501A27-8065-4092-950E-D48588947109">
+ <variable name="A" id="_334D69F6-B103-43C5-864D-E11D7592E37B"
typeRef="tNumbers" />
+ </inputData>
+ <decision name="B" id="_B6B9BE82-F9B3-445E-A9B3-283B72049A40">
+ <variable id="_A78B44E3-D25B-4F29-9068-F913C0E7D048" typeRef="tStrings"
name="B" />
+ <informationRequirement id="_7A1EC83C-F1E6-406F-BF6E-1077D5817267">
+ <requiredInput href="#_6A501A27-8065-4092-950E-D48588947109" />
+ </informationRequirement>
+ <for id="_14BD7087-3A8B-47E9-A35F-BE99C10B1D6A" label="B"
typeRef="tStrings" iteratorVariable="num">
+ <in id="_F96A6E4B-57F8-468A-A10D-4B2A36405740">
+ <literalExpression id="_D63D1584-E40B-46E8-9BCB-394409BD85EA"
label="Expression Name">
+ <text>A</text>
+ </literalExpression>
+ </in>
+ <return id="_C8B97A86-447C-4A85-9548-606992DB4BA0">
+ <conditional id="_096DC616-A4D5-449C-A350-491E42F3C8FB"
label="Expression Name">
+ <if id="_96D34F2E-3CC0-45A6-9455-2F960361A9CC">
+ <literalExpression id="_B8A93708-E198-441D-B7E6-864EC38F2327"
label="Expression Name">
+ <text>num > 0</text>
+ </literalExpression>
+ </if>
+ <then id="_F9D2FA33-4604-4AAA-8FF1-5A4AC5055385">
+ <literalExpression id="_1D17D490-0E62-4908-A86D-CE016CFDDFC6"
label="Expression Name">
+ <text>"pos"</text>
+ </literalExpression>
+ </then>
+ <else id="_7C843AB8-961C-4A95-83B3-2D1593DF297C">
+ <literalExpression id="_263A269D-E102-476D-A425-7CA37A13BA88"
label="Expression Name">
+ <text>"neg"</text>
+ </literalExpression>
+ </else>
+ </conditional>
+ </return>
+ </for>
+ </decision>
+ <dmndi:DMNDI>
+ <dmndi:DMNDiagram id="_A7FF7960-31EC-4C81-97E6-BBF171AFBDD9" name="Default
DRD" useAlternativeInputDataShape="false">
+ <di:extension>
+ <kie:ComponentsWidthsExtension>
+ <kie:ComponentWidths
dmnElementRef="_D63D1584-E40B-46E8-9BCB-394409BD85EA">
+ <kie:width>190</kie:width>
+ </kie:ComponentWidths>
+ <kie:ComponentWidths
dmnElementRef="_6BF25BA6-026C-4F75-8931-64ED44CFBC9D">
+ <kie:width>190</kie:width>
+ </kie:ComponentWidths>
+ <kie:ComponentWidths
dmnElementRef="_B8A93708-E198-441D-B7E6-864EC38F2327">
+ <kie:width>190</kie:width>
+ </kie:ComponentWidths>
+ <kie:ComponentWidths
dmnElementRef="_1D17D490-0E62-4908-A86D-CE016CFDDFC6">
+ <kie:width>190</kie:width>
+ </kie:ComponentWidths>
+ <kie:ComponentWidths
dmnElementRef="_263A269D-E102-476D-A425-7CA37A13BA88">
+ <kie:width>190</kie:width>
+ </kie:ComponentWidths>
+ </kie:ComponentsWidthsExtension>
+ </di:extension>
+ <dmndi:DMNShape id="_FA54D060-A653-448D-9C7A-EF813354D100"
dmnElementRef="_6A501A27-8065-4092-950E-D48588947109" isCollapsed="false"
isListedInputData="false">
+ <dc:Bounds x="200" y="100" width="160" height="80" />
+ </dmndi:DMNShape>
+ <dmndi:DMNShape id="_5E8A73C9-B9D6-4727-A6B0-7B24CD744A54"
dmnElementRef="_B6B9BE82-F9B3-445E-A9B3-283B72049A40" isCollapsed="false"
isListedInputData="false">
+ <dc:Bounds x="480" y="100" width="160" height="80" />
+ </dmndi:DMNShape>
+ <dmndi:DMNEdge id="_1AAE4FD6-0B9F-4258-8D56-9A25257B917B"
dmnElementRef="_7A1EC83C-F1E6-406F-BF6E-1077D5817267"
sourceElement="_FA54D060-A653-448D-9C7A-EF813354D100"
targetElement="_5E8A73C9-B9D6-4727-A6B0-7B24CD744A54">
+ <di:waypoint x="280" y="140" />
+ <di:waypoint x="560" y="140" />
+ </dmndi:DMNEdge>
+ </dmndi:DMNDiagram>
+ </dmndi:DMNDI>
+</definitions>
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
