Drive End and IntermediateThrow event validation through getSupportedLocations()

Align EndEventValidator and IntermediateThrowEventValidator with the four
already-refactored placement validators so all six EventDefinitionLocation
values are enforced. Built-ins keep their existing behavior; custom
EventDefinitions declaring END_EVENT or INTERMEDIATE_THROW_EVENT support
are now valid at those placements.

Author: filiphr

modules/flowable-engine/src/test/java/org/flowable/standalone/validation/DefaultProcessValidatorTest.java

@@ -34,6 +34,7 @@
 import org.flowable.bpmn.model.SequenceFlow;
 import org.flowable.bpmn.model.StartEvent;
 import org.flowable.bpmn.model.TerminateEventDefinition;
+import org.flowable.bpmn.model.TimerEventDefinition;
 import org.flowable.bpmn.model.UserTask;
 import org.flowable.common.engine.api.io.InputStreamProvider;
 import org.flowable.engine.test.util.TestProcessUtil;
@@ -415,6 +416,36 @@ void testBoundaryEventWithUnsupportedDefinition() {
                         tuple(Problems.BOUNDARY_EVENT_INVALID_EVENT_DEFINITION, "Invalid or unsupported event definition", "invalidBoundaryEvent", false));
     }
 
+    @Test
+    void testEndEventWithUnsupportedDefinition() {
+        BpmnModel bpmnModel = new BpmnModel();
+        Process process = new Process();
+        process.setId("endEventWithUnsupportedDefinition");
+        process.setExecutable(true);
+        bpmnModel.addProcess(process);
+
+        StartEvent start = new StartEvent();
+        start.setId("start");
+        process.addFlowElement(start);
+
+        EndEvent end = new EndEvent();
+        end.setId("invalidEndEvent");
+        end.setName("Invalid End Event");
+        TimerEventDefinition timerEventDefinition = new TimerEventDefinition();
+        timerEventDefinition.setTimeDuration("PT5M");
+        end.addEventDefinition(timerEventDefinition);
+        process.addFlowElement(end);
+
+        process.addFlowElement(new SequenceFlow("start", "invalidEndEvent"));
+
+        List<ValidationError> errors = processValidator.validate(bpmnModel);
+
+        assertThat(errors)
+                .extracting(ValidationError::getProblem, ValidationError::getDefaultDescription, ValidationError::getActivityId, ValidationError::isWarning)
+                .containsExactly(
+                        tuple(Problems.END_EVENT_INVALID_EVENT_DEFINITION, "Invalid or unsupported event definition", "invalidEndEvent", false));
+    }
+
     @Test
     void testInvalidMultiInstanceActivity() {
         BpmnModel bpmnModel = readBpmnModelFromXml("org/flowable/standalone/validation/invalidMultiInstanceActivity.bpmn20.xml");

modules/flowable-process-validation/src/main/java/org/flowable/validation/validator/Problems.java

@@ -134,6 +134,7 @@ public interface Problems {
     String DATA_OBJECT_MISSING_NAME = "flowable-data-object-missing-name";
 
     String END_EVENT_CANCEL_ONLY_INSIDE_TRANSACTION = "flowable-end-event-cancel-only-inside-transaction";
+    String END_EVENT_INVALID_EVENT_DEFINITION = "flowable-end-event-invalid-event-definition";
 
     String DI_INVALID_REFERENCE = "flowable-di-invalid-reference";
     String DI_DOES_NOT_REFERENCE_FLOWNODE = "flowable-di-does-not-reference-flownode";

modules/flowable-process-validation/src/main/java/org/flowable/validation/validator/impl/EndEventValidator.java

@@ -18,6 +18,7 @@
 import org.flowable.bpmn.model.CancelEventDefinition;
 import org.flowable.bpmn.model.EndEvent;
 import org.flowable.bpmn.model.EventDefinition;
+import org.flowable.bpmn.model.EventDefinitionLocation;
 import org.flowable.bpmn.model.FlowElementsContainer;
 import org.flowable.bpmn.model.Process;
 import org.flowable.bpmn.model.Transaction;
@@ -34,20 +35,20 @@ public class EndEventValidator extends ProcessLevelValidator {
     protected void executeValidation(BpmnModel bpmnModel, Process process, ProcessValidationContext validationContext) {
         List<EndEvent> endEvents = process.findFlowElementsOfType(EndEvent.class);
         for (EndEvent endEvent : endEvents) {
-            if (endEvent.getEventDefinitions() != null && !endEvent.getEventDefinitions().isEmpty()) {
-
-                EventDefinition eventDefinition = endEvent.getEventDefinitions().get(0);
-
-                // Error end event
-                if (eventDefinition instanceof CancelEventDefinition) {
+            if (endEvent.getEventDefinitions() == null || endEvent.getEventDefinitions().isEmpty()) {
+                continue;
+            }
+            EventDefinition eventDefinition = endEvent.getEventDefinitions().get(0);
 
-                    FlowElementsContainer parent = process.findParent(endEvent);
-                    if (!(parent instanceof Transaction)) {
-                        validationContext.addError(Problems.END_EVENT_CANCEL_ONLY_INSIDE_TRANSACTION, process, endEvent, "end event with cancelEventDefinition only supported inside transaction subprocess");
-                    }
+            if (!eventDefinition.getSupportedLocations().contains(EventDefinitionLocation.END_EVENT)) {
+                validationContext.addError(Problems.END_EVENT_INVALID_EVENT_DEFINITION, process, endEvent, eventDefinition, "Invalid or unsupported event definition");
+            }
 
+            if (eventDefinition instanceof CancelEventDefinition) {
+                FlowElementsContainer parent = process.findParent(endEvent);
+                if (!(parent instanceof Transaction)) {
+                    validationContext.addError(Problems.END_EVENT_CANCEL_ONLY_INSIDE_TRANSACTION, process, endEvent, "end event with cancelEventDefinition only supported inside transaction subprocess");
                 }
-
             }
         }
     }

modules/flowable-process-validation/src/main/java/org/flowable/validation/validator/impl/IntermediateThrowEventValidator.java

@@ -15,11 +15,9 @@
 import java.util.List;
 
 import org.flowable.bpmn.model.BpmnModel;
-import org.flowable.bpmn.model.CompensateEventDefinition;
-import org.flowable.bpmn.model.EscalationEventDefinition;
 import org.flowable.bpmn.model.EventDefinition;
+import org.flowable.bpmn.model.EventDefinitionLocation;
 import org.flowable.bpmn.model.Process;
-import org.flowable.bpmn.model.SignalEventDefinition;
 import org.flowable.bpmn.model.ThrowEvent;
 import org.flowable.validation.ProcessValidationContext;
 import org.flowable.validation.validator.Problems;
@@ -34,14 +32,11 @@ public class IntermediateThrowEventValidator extends ProcessLevelValidator {
     protected void executeValidation(BpmnModel bpmnModel, Process process, ProcessValidationContext validationContext) {
         List<ThrowEvent> throwEvents = process.findFlowElementsOfType(ThrowEvent.class);
         for (ThrowEvent throwEvent : throwEvents) {
-            EventDefinition eventDefinition = null;
-            if (!throwEvent.getEventDefinitions().isEmpty()) {
-                eventDefinition = throwEvent.getEventDefinitions().get(0);
+            if (throwEvent.getEventDefinitions().isEmpty()) {
+                continue;
             }
-
-            if (eventDefinition != null && !(eventDefinition instanceof SignalEventDefinition) &&
-                            !(eventDefinition instanceof EscalationEventDefinition) && !(eventDefinition instanceof CompensateEventDefinition)) {
-
+            EventDefinition eventDefinition = throwEvent.getEventDefinitions().get(0);
+            if (!eventDefinition.getSupportedLocations().contains(EventDefinitionLocation.INTERMEDIATE_THROW_EVENT)) {
                 validationContext.addError(Problems.THROW_EVENT_INVALID_EVENTDEFINITION, process, throwEvent, eventDefinition, "Unsupported intermediate throw event type");
             }
         }