Merge branch 'master' of https://github.com/Activiti/Activiti

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiActivityEvent.java

+/* Licensed 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.
+ */
+package org.activiti.engine.delegate.event;
+
+
+/**
+ * An {@link ActivitiEvent} related to an activity within an execution;
+ * 
+ * @author Frederik Heremans
+ */
+public interface ActivitiActivityEvent extends ActivitiEvent {
+
+	/**
+	 * @return the id of the activity this event is related to. This corresponds to an 
+	 * id defined in the process definition.
+	 */
+	public String getActivityId();
+
+}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivityEntityEvent.java → modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiEntityEvent.java

@@ -18,7 +18,7 @@ package org.activiti.engine.delegate.event;
  * 
  * @author Frederik Heremans
  */
-public interface ActivityEntityEvent extends ActivitiEvent {
+public interface ActivitiEntityEvent extends ActivitiEvent {
 	
 	/**
 	 * @return the entity that is targeted by this event.

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiEventType.java

@@ -85,7 +85,27 @@ public enum ActivitiEventType {
 	/**
 	 * The process-engine that dispatched this event has been closed and cannot be used anymore.
 	 */
-	ENGINE_CLOSED;
+	ENGINE_CLOSED,
+	
+	ACTIVITY_COMPLETE,
+	
+	/**
+	 * An activity has received a signal. Dispatched after the activity has responded to the signal.
+	 */
+	ACTIVITY_SIGNALLED,
+	
+	/**
+	 * An activity is about to be executed as a compensation for another activity. The event targets the
+	 * activity that is about to be executed for compensation.
+	 */
+	ACTIVITY_COMPENSATE,
+	
+	/**
+	 * An activity has received a message event. Dispatched before the actual message has been received by
+	 * the activity. This event will be either followed by a {@link #ACTIVITY_SIGNALLED} event or {@link #ACTIVITY_COMPLETE}
+	 * for the involved activity, if the message was delivered successfully.
+	 */
+	ACTIVITY_MESSAGE_RECEIVED;
 	
 	
 	public static final ActivitiEventType[] EMPTY_ARRAY =  new ActivitiEventType[] {};

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiMessageEvent.java

+/* Licensed 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.
+ */
+package org.activiti.engine.delegate.event;
+
+
+/**
+ * An {@link ActivitiEvent} related to an message being sent to an activity.
+ * 
+ * @author Frederik Heremans
+ */
+public interface ActivitiMessageEvent extends ActivitiActivityEvent {
+
+	/**
+	 * @return the name of the message.
+	 */
+	public String getMessageName();
+	
+	/**
+	 * @return the payload that was passed when sending the message. Returns null, if no payload was passed.
+	 */
+	public Object getMessageData();
+
+}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/ActivitiSignalEvent.java

+/* Licensed 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.
+ */
+package org.activiti.engine.delegate.event;
+
+
+/**
+ * An {@link ActivitiEvent} related to a signal being sent to an activity.
+ * 
+ * @author Frederik Heremans
+ */
+public interface ActivitiSignalEvent extends ActivitiActivityEvent {
+
+	/**
+	 * @return the name of the signal. Returns null, if no specific signal name has been specified
+	 * when signaling.
+	 */
+	public String getSignalName();
+	
+	/**
+	 * @return the payload that was passed when signaling. Returns null, if no payload was passed.
+	 */
+	public Object getSignalData();
+
+}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/BaseEntityEventListener.java

@@ -75,16 +75,16 @@ public class BaseEntityEventListener implements ActivitiEventListener {
 	}
 
 	/**
-	 * @return true, if the event is an {@link ActivityEntityEvent} and (if needed) the entityClass
+	 * @return true, if the event is an {@link ActivitiEntityEvent} and (if needed) the entityClass
 	 * set in this instance, is assignable from the entity class in the event. 
 	 */
 	protected boolean isValidEvent(ActivitiEvent event) {
 		boolean valid = false;
-		if(event instanceof ActivityEntityEvent) {
+		if(event instanceof ActivitiEntityEvent) {
 			if(entityClass == null) {
 				valid = true;
 			} else {
-				valid = entityClass.isAssignableFrom(((ActivityEntityEvent) event).getEntity().getClass());
+				valid = entityClass.isAssignableFrom(((ActivitiEntityEvent) event).getEntity().getClass());
 			}
 		}
 		return valid;

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiActivityEventImpl.java

+/* Licensed 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.
+ */
+package org.activiti.engine.delegate.event.impl;
+
+import org.activiti.engine.delegate.event.ActivitiActivityEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+
+/**
+ * Implementation of an {@link ActivitiActivityEvent}.
+ * 
+ * @author Frederik Heremans
+ */
+public class ActivitiActivityEventImpl extends ActivitiEventImpl implements ActivitiActivityEvent {
+
+	protected String activityId;
+	
+	public ActivitiActivityEventImpl(ActivitiEventType type) {
+	  super(type);
+  }
+
+	@Override
+  public String getActivityId() {
+		return activityId;
+  }
+	
+	public void setActivityId(String activityId) {
+	  this.activityId = activityId;
+  }
+}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiEntityEventImpl.java

@@ -15,14 +15,14 @@ package org.activiti.engine.delegate.event.impl;
 import org.activiti.engine.ActivitiIllegalArgumentException;
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 
 /**
  * Base class for all {@link ActivitiEvent} implementations, related to entities.
  * 
  * @author Frederik Heremans
  */
-public class ActivitiEntityEventImpl extends ActivitiEventImpl implements ActivityEntityEvent {
+public class ActivitiEntityEventImpl extends ActivitiEventImpl implements ActivitiEntityEvent {
 
 	protected Object entity;
 	

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiEntityExceptionEventImpl.java

@@ -16,7 +16,7 @@ import org.activiti.engine.ActivitiIllegalArgumentException;
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
 import org.activiti.engine.delegate.event.ActivitiExceptionEvent;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 
 /**
  * Base class for all {@link ActivitiEvent} implementations, represents an exception occured, related 
@@ -24,7 +24,7 @@ import org.activiti.engine.delegate.event.ActivityEntityEvent;
  * 
  * @author Frederik Heremans
  */
-public class ActivitiEntityExceptionEventImpl extends ActivitiEventImpl implements ActivityEntityEvent, ActivitiExceptionEvent {
+public class ActivitiEntityExceptionEventImpl extends ActivitiEventImpl implements ActivitiEntityEvent, ActivitiExceptionEvent {
 
 	protected Object entity;
 	protected Throwable cause;

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiEventBuilder.java

@@ -12,13 +12,17 @@
  */
 package org.activiti.engine.delegate.event.impl;
 
+import org.activiti.engine.delegate.DelegateExecution;
+import org.activiti.engine.delegate.event.ActivitiActivityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
 import org.activiti.engine.delegate.event.ActivitiExceptionEvent;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiMessageEvent;
+import org.activiti.engine.delegate.event.ActivitiSignalEvent;
 import org.activiti.engine.impl.context.Context;
 import org.activiti.engine.impl.context.ExecutionContext;
-import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
+import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;
 import org.activiti.engine.runtime.Job;
 
 /**
@@ -41,10 +45,10 @@ public class ActivitiEventBuilder {
 	/**
 	 * @param type type of event
 	 * @param entity the entity this event targets
-	 * @return an {@link ActivityEntityEvent}. In case an {@link ExecutionContext} is active, the execution related
+	 * @return an {@link ActivitiEntityEvent}. In case an {@link ExecutionContext} is active, the execution related
 	 * event fields will be populated. If not, execution details will be reteived from the {@link Object} if possible.
 	 */
-	public static ActivityEntityEvent createEntityEvent(ActivitiEventType type, Object entity) {
+	public static ActivitiEntityEvent createEntityEvent(ActivitiEventType type, Object entity) {
 		ActivitiEntityEventImpl newEvent = new ActivitiEntityEventImpl(entity, type);
 
 		// In case an execution-context is active, populate the event fields related to the execution
@@ -55,9 +59,9 @@ public class ActivitiEventBuilder {
 	/**
 	 * @param type type of event
 	 * @param entity the entity this event targets
-	 * @return an {@link ActivityEntityEvent}
+	 * @return an {@link ActivitiEntityEvent}
 	 */
-	public static ActivityEntityEvent createEntityEvent(ActivitiEventType type, Object entity, String executionId,
+	public static ActivitiEntityEvent createEntityEvent(ActivitiEventType type, Object entity, String executionId,
 			String processInstanceId, String processDefinitionId) {
 		ActivitiEntityEventImpl newEvent = new ActivitiEntityEventImpl(entity, type);
 
@@ -71,10 +75,10 @@ public class ActivitiEventBuilder {
 	 * @param type type of event
 	 * @param entity the entity this event targets
 	 * @param cause the cause of the event
-	 * @return an {@link ActivityEntityEvent} that is also instance of {@link ActivitiExceptionEvent}. 
+	 * @return an {@link ActivitiEntityEvent} that is also instance of {@link ActivitiExceptionEvent}. 
 	 * In case an {@link ExecutionContext} is active, the execution related event fields will be populated.
 	 */
-	public static ActivityEntityEvent createEntityExceptionEvent(ActivitiEventType type, Object entity, Throwable cause) {
+	public static ActivitiEntityEvent createEntityExceptionEvent(ActivitiEventType type, Object entity, Throwable cause) {
 		ActivitiEntityExceptionEventImpl newEvent = new ActivitiEntityExceptionEventImpl(entity, type, cause);
 
 		// In case an execution-context is active, populate the event fields related to the execution
@@ -86,9 +90,9 @@ public class ActivitiEventBuilder {
 	 * @param type type of event
 	 * @param entity the entity this event targets
 	 * @param cause the cause of the event
-	 * @return an {@link ActivityEntityEvent} that is also instance of {@link ActivitiExceptionEvent}. 
+	 * @return an {@link ActivitiEntityEvent} that is also instance of {@link ActivitiExceptionEvent}. 
 	 */
-	public static ActivityEntityEvent createEntityExceptionEvent(ActivitiEventType type, Object entity, Throwable cause, String executionId,
+	public static ActivitiEntityEvent createEntityExceptionEvent(ActivitiEventType type, Object entity, Throwable cause, String executionId,
 			String processInstanceId, String processDefinitionId) {
 		ActivitiEntityExceptionEventImpl newEvent = new ActivitiEntityExceptionEventImpl(entity, type, cause);
 
@@ -98,26 +102,76 @@ public class ActivitiEventBuilder {
 		return newEvent;
 	}
 	
+	public static ActivitiActivityEvent createActivityEvent(ActivitiEventType type, String activityId, String executionId, String processInstanceId, String processDefinitionId) {
+		ActivitiActivityEventImpl newEvent = new ActivitiActivityEventImpl(type);
+		newEvent.setActivityId(activityId);
+		newEvent.setExecutionId(executionId);
+		newEvent.setProcessDefinitionId(processDefinitionId);
+		newEvent.setProcessInstanceId(processInstanceId);
+		return newEvent;
+	}
+	
+	public static ActivitiSignalEvent createSignalEvent(ActivitiEventType type, String activityId, String signalName, Object signalData, 
+			String executionId, String processInstanceId, String processDefinitionId) {
+		ActivitiSignalEventImpl newEvent = new ActivitiSignalEventImpl(type);
+		newEvent.setActivityId(activityId);
+		newEvent.setExecutionId(executionId);
+		newEvent.setProcessDefinitionId(processDefinitionId);
+		newEvent.setProcessInstanceId(processInstanceId);
+		newEvent.setSignalName(signalName);
+		newEvent.setSignalData(signalData);
+		return newEvent;
+	}
+	
+	public static ActivitiMessageEvent createMessageEvent(ActivitiEventType type, String activityId, String messageName, Object payload, 
+			String executionId, String processInstanceId, String processDefinitionId) {
+		ActivitiMessageEventImpl newEvent = new ActivitiMessageEventImpl(type);
+		newEvent.setActivityId(activityId);
+		newEvent.setExecutionId(executionId);
+		newEvent.setProcessDefinitionId(processDefinitionId);
+		newEvent.setProcessInstanceId(processInstanceId);
+		newEvent.setMessageName(messageName);
+		newEvent.setMessageData(payload);
+		return newEvent;
+	}
+	
 	protected static void populateEventWithCurrentContext(ActivitiEventImpl event) {
+		boolean extractedFromContext = false;
 		if(Context.isExecutionContextActive()) {
 			ExecutionContext executionContext = Context.getExecutionContext();
 			if(executionContext != null) {
+				extractedFromContext = true;
 				event.setExecutionId(executionContext.getExecution().getId());
 				event.setProcessInstanceId(executionContext.getExecution().getProcessInstanceId());
 				event.setProcessDefinitionId(executionContext.getExecution().getProcessDefinitionId());
 			}
-		} else {
-			// Fallback to fetching context from the object itself
-			if(event instanceof ActivityEntityEvent) {
-				Object persistendObject = ((ActivityEntityEvent) event).getEntity();
+		} 
+		
+		// Fallback to fetching context from the object itself
+		if(!extractedFromContext){
+			if(event instanceof ActivitiEntityEvent) {
+				Object persistendObject = ((ActivitiEntityEvent) event).getEntity();
 				if(persistendObject instanceof Job) {
 					event.setExecutionId(((Job) persistendObject).getExecutionId());
 					event.setProcessInstanceId(((Job) persistendObject).getProcessInstanceId());
 					event.setProcessDefinitionId(((Job) persistendObject).getProcessDefinitionId());
-				} else if(persistendObject instanceof ExecutionEntity) {
-					event.setExecutionId(((ExecutionEntity) persistendObject).getId());
-					event.setProcessInstanceId(((ExecutionEntity) persistendObject).getProcessInstanceId());
-					event.setProcessDefinitionId(((ExecutionEntity) persistendObject).getProcessDefinitionId());
+				} else if(persistendObject instanceof DelegateExecution) {
+					event.setExecutionId(((DelegateExecution) persistendObject).getId());
+					event.setProcessInstanceId(((DelegateExecution) persistendObject).getProcessInstanceId());
+					event.setProcessDefinitionId(((DelegateExecution) persistendObject).getProcessDefinitionId());
+				} else if(persistendObject instanceof IdentityLinkEntity) {
+					IdentityLinkEntity idLink = (IdentityLinkEntity) persistendObject;
+					if(idLink.getProcessDefinitionId() != null) {
+						event.setProcessDefinitionId(idLink.getProcessDefId());
+					} else if(idLink.getProcessInstance() != null) {
+						event.setProcessDefinitionId(idLink.getProcessInstance().getProcessDefinitionId());
+						event.setProcessInstanceId(idLink.getProcessInstanceId());
+						event.setExecutionId(idLink.getProcessInstanceId());
+					} else if(idLink.getTask() != null) {
+						event.setProcessDefinitionId(idLink.getTask().getProcessDefinitionId());
+						event.setProcessInstanceId(idLink.getTask().getProcessInstanceId());
+						event.setExecutionId(idLink.getTask().getExecutionId());
+					}
 				}
 			}
 		}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiMessageEventImpl.java

+/* Licensed 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.
+ */
+package org.activiti.engine.delegate.event.impl;
+
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiMessageEvent;
+import org.activiti.engine.delegate.event.ActivitiSignalEvent;
+
+/**
+ * An {@link ActivitiSignalEvent} implementation.
+ * 
+ * @author Frederik Heremans
+ */
+public class ActivitiMessageEventImpl extends ActivitiActivityEventImpl implements ActivitiMessageEvent {
+
+	protected String messageName;
+	protected Object messageData;
+	
+	public ActivitiMessageEventImpl(ActivitiEventType type) {
+	  super(type);
+  }
+	
+	public void setMessageName(String messageName) {
+	  this.messageName = messageName;
+  }
+	
+	public String getMessageName() {
+	  return messageName;
+  }
+	
+	public void setMessageData(Object messageData) {
+	  this.messageData = messageData;
+  }
+	
+	public Object getMessageData() {
+	  return messageData;
+  }
+}

modules/activiti-engine/src/main/java/org/activiti/engine/delegate/event/impl/ActivitiSignalEventImpl.java

+/* Licensed 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.
+ */
+package org.activiti.engine.delegate.event.impl;
+
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiSignalEvent;
+
+/**
+ * An {@link ActivitiSignalEvent} implementation.
+ * 
+ * @author Frederik Heremans
+ */
+public class ActivitiSignalEventImpl extends ActivitiActivityEventImpl implements ActivitiSignalEvent {
+
+	protected String signalName;
+	protected Object signalData;
+	
+	public ActivitiSignalEventImpl(ActivitiEventType type) {
+	  super(type);
+  }
+
+	@Override
+  public String getSignalName() {
+		return signalName;
+  }
+	
+	public void setSignalName(String signalName) {
+	  this.signalName = signalName;
+  }
+
+	@Override
+  public Object getSignalData() {
+		return signalData;
+  }
+	
+	public void setSignalData(Object signalData) {
+	  this.signalData = signalData;
+  }
+}

modules/activiti-engine/src/main/java/org/activiti/engine/impl/cmd/AbstractSetProcessDefinitionStateCmd.java

@@ -20,8 +20,6 @@ import java.util.List;
 import org.activiti.engine.ActivitiException;
 import org.activiti.engine.ActivitiIllegalArgumentException;
 import org.activiti.engine.ActivitiObjectNotFoundException;
-import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.impl.ProcessDefinitionQueryImpl;
 import org.activiti.engine.impl.ProcessInstanceQueryImpl;
 import org.activiti.engine.impl.context.Context;
@@ -160,17 +158,6 @@ public abstract class AbstractSetProcessDefinitionStateCmd implements Command<Vo
           processInstances = fetchProcessInstancesPage(commandContext, processDefinition, currentStartIndex);
         }
       }
-      
-      if(Context.getCommandContext().getEventDispatcher().isEnabled()) {
-      	ActivitiEventType eventType = null;
-      	if(getProcessDefinitionSuspensionState() == SuspensionState.ACTIVE) {
-      		eventType = ActivitiEventType.ENTITY_ACTIVATED;
-      	} else {
-      		eventType = ActivitiEventType.ENTITY_SUSPENDED;
-      	}
-      	Context.getCommandContext().getEventDispatcher().dispatchEvent(
-      			ActivitiEventBuilder.createEntityEvent(eventType, processDefinition));
-      }
     }
   }
   

modules/activiti-engine/src/main/java/org/activiti/engine/impl/cmd/MessageEventReceivedCmd.java

@@ -63,6 +63,7 @@ public class MessageEventReceivedCmd extends NeedsActiveExecutionCmd<Void> {
     this.payload = null;
     this.async = async;
   }
+  
   protected Void execute(CommandContext commandContext, ExecutionEntity execution) {
     if(messageName == null) {
       throw new ActivitiIllegalArgumentException("messageName cannot be null");

modules/activiti-engine/src/main/java/org/activiti/engine/impl/event/AbstractEventHandler.java

@@ -64,7 +64,7 @@ public abstract class AbstractEventHandler implements EventHandler {
       if (!activity.equals( execution.getActivity() )) {
         execution.setActivity(activity);
       }
-      execution.signal("signal", null);
+      execution.signal(eventSubscription.getEventName(), payload);
     }
 
   }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/event/CompensationEventHandler.java

@@ -16,6 +16,8 @@ package org.activiti.engine.impl.event;
 import java.util.List;
 
 import org.activiti.engine.ActivitiException;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
 import org.activiti.engine.impl.bpmn.helper.ScopeUtil;
 import org.activiti.engine.impl.bpmn.parser.BpmnParse;
 import org.activiti.engine.impl.interceptor.CommandContext;
@@ -60,6 +62,11 @@ public class CompensationEventHandler implements EventHandler {
     } else {
       try {
 
+      	if(commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+      		commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+      				ActivitiEventBuilder.createActivityEvent(ActivitiEventType.ACTIVITY_COMPENSATE, compensationHandler.getId(), compensatingExecution.getId(), 
+      						compensatingExecution.getProcessInstanceId(), compensatingExecution.getProcessDefinitionId()));
+      	}
         compensatingExecution.setActivity(compensationHandler);
         
         // executing the atomic operation makes sure activity start events are fired

modules/activiti-engine/src/main/java/org/activiti/engine/impl/event/MessageEventHandler.java

@@ -13,6 +13,11 @@
 
 package org.activiti.engine.impl.event;
 
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
+import org.activiti.engine.impl.interceptor.CommandContext;
+import org.activiti.engine.impl.persistence.entity.EventSubscriptionEntity;
+
 
 
 /**
@@ -25,5 +30,17 @@ public class MessageEventHandler extends AbstractEventHandler {
   public String getEventHandlerType() {
     return EVENT_HANDLER_TYPE;
   }
+  
+  @Override
+  public void handleEvent(EventSubscriptionEntity eventSubscription, Object payload, CommandContext commandContext) {
+  	// As stated in the ActivitiEventType java-doc, the message-event is thrown before the actual message has been sent
+  	if(commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+    	commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+    			ActivitiEventBuilder.createMessageEvent(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, eventSubscription.getActivityId(), eventSubscription.getEventName(), 
+    					payload, eventSubscription.getExecutionId(), eventSubscription.getProcessInstanceId(), eventSubscription.getExecution().getProcessDefinitionId()));
+    }
+  	
+    super.handleEvent(eventSubscription, payload, commandContext);
+  }
 
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/CompensateEventSubscriptionEntity.java

@@ -24,7 +24,6 @@ public class CompensateEventSubscriptionEntity extends EventSubscriptionEntity {
   
   private static final long serialVersionUID = 1L;
   
-  @SuppressWarnings("unused") // used by mybatis
   private CompensateEventSubscriptionEntity() {
   }
 

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/ExecutionEntity.java

@@ -19,6 +19,10 @@ import java.util.List;
 import java.util.Map;
 
 import org.activiti.engine.EngineServices;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
+import org.activiti.engine.impl.bpmn.behavior.MultiInstanceActivityBehavior;
+import org.activiti.engine.impl.bpmn.behavior.UserTaskActivityBehavior;
 import org.activiti.engine.impl.bpmn.parser.BpmnParse;
 import org.activiti.engine.impl.bpmn.parser.EventSubscriptionDeclaration;
 import org.activiti.engine.impl.context.Context;
@@ -347,7 +351,20 @@ public class ExecutionEntity extends VariableScopeImpl implements ActivityExecut
     ensureActivityInitialized();
     SignallableActivityBehavior activityBehavior = (SignallableActivityBehavior) activity.getActivityBehavior();
     try {
+    	String signalledActivityId = activity.getId();
       activityBehavior.signal(this, signalName, signalData);
+      
+      // If needed, dispatch an event indicating an activity was signalled
+      boolean isUserTask = (activityBehavior instanceof UserTaskActivityBehavior)
+      		|| ((activityBehavior instanceof MultiInstanceActivityBehavior) 
+      				&& ((MultiInstanceActivityBehavior) activityBehavior).getInnerActivityBehavior() instanceof UserTaskActivityBehavior);
+      
+      if(!isUserTask && Context.getProcessEngineConfiguration() != null 
+      		&& Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+      	Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder.createSignalEvent(
+      		ActivitiEventType.ACTIVITY_SIGNALLED, signalledActivityId, signalName, signalData, this.id, this.processInstanceId, this.processDefinitionId));
+      }
+      
     } catch (RuntimeException e) {
       throw e;
     } catch (Exception e) {
@@ -1403,6 +1420,12 @@ public class ExecutionEntity extends VariableScopeImpl implements ActivityExecut
     if (isProcessInstanceType() && bzKey != null) {
       setBusinessKey(bzKey);
       Context.getCommandContext().getHistoryManager().updateProcessBusinessKeyInHistory(this);
+      
+      if(Context.getProcessEngineConfiguration() != null && Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+      	Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+      			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_UPDATED, this));
+      }
+      
       return bzKey;
     }
     return null;

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/IdentityLinkEntityManager.java

@@ -96,11 +96,22 @@ public class IdentityLinkEntityManager extends AbstractManager {
       deleteIdentityLink(identityLink, false);
     }
     
-    // Identity links from cache
+    // Identity links from cache, if not already deleted
     List<IdentityLinkEntity> identityLinksFromCache = Context.getCommandContext().getDbSqlSession().findInCache(IdentityLinkEntity.class);
+    boolean alreadyDeleted = false;
     for (IdentityLinkEntity identityLinkEntity : identityLinksFromCache) {
       if (processInstanceId.equals(identityLinkEntity.getProcessInstanceId())) {
-        deleteIdentityLink(identityLinkEntity, false);
+      	alreadyDeleted = false;
+      	for(IdentityLinkEntity deleted : identityLinks) {
+      		if(deleted.getId() != null && deleted.getId().equals(identityLinkEntity.getId())) {
+      			alreadyDeleted = true;
+      			break;
+      		}
+      	}
+      	
+      	if(!alreadyDeleted) {
+      		deleteIdentityLink(identityLinkEntity, false);
+      	}
       }
     }
   }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/SuspensionState.java

@@ -13,6 +13,9 @@
 package org.activiti.engine.impl.persistence.entity;
 
 import org.activiti.engine.ActivitiException;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
+import org.activiti.engine.impl.context.Context;
 
 /**
  * Contains a predefined set of states for process definitions and process instances
@@ -79,6 +82,7 @@ public interface SuspensionState {
         throw new ActivitiException("Cannot set suspension state '"+state+"' for "+processDefinitionEntity+"': already in state '"+state+"'.");
       }
       processDefinitionEntity.setSuspensionState(state.getStateCode());
+      dispatchStateChangeEvent(processDefinitionEntity, state);
     }
     
     public static void setSuspensionState(ExecutionEntity executionEntity, SuspensionState state) {
@@ -86,6 +90,7 @@ public interface SuspensionState {
         throw new ActivitiException("Cannot set suspension state '"+state+"' for "+executionEntity+"': already in state '"+state+"'.");
       }
       executionEntity.setSuspensionState(state.getStateCode());
+      dispatchStateChangeEvent(executionEntity, state);
     }
     
     public static void setSuspensionState(TaskEntity taskEntity, SuspensionState state) {
@@ -93,6 +98,20 @@ public interface SuspensionState {
         throw new ActivitiException("Cannot set suspension state '"+state+"' for " + taskEntity + "': already in state '"+state+"'.");
       }
       taskEntity.setSuspensionState(state.getStateCode());
+      dispatchStateChangeEvent(taskEntity, state);
+    }
+    
+    protected static void dispatchStateChangeEvent(Object entity, SuspensionState state) {
+    	if(Context.getCommandContext() != null && Context.getCommandContext().getEventDispatcher().isEnabled()) {
+      	ActivitiEventType eventType = null;
+      	if(state == SuspensionState.ACTIVE) {
+      		eventType = ActivitiEventType.ENTITY_ACTIVATED;
+      	} else {
+      		eventType = ActivitiEventType.ENTITY_SUSPENDED;
+      	}
+      	Context.getCommandContext().getEventDispatcher().dispatchEvent(
+      			ActivitiEventBuilder.createEntityEvent(eventType, entity));
+      }
     }
   }
   

modules/activiti-engine/src/main/java/org/activiti/engine/impl/pvm/runtime/AtomicOperationDeleteCascadeFireActivityEnd.java

@@ -13,7 +13,9 @@
 
 package org.activiti.engine.impl.pvm.runtime;
 
-import org.activiti.engine.delegate.ExecutionListener;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
+import org.activiti.engine.impl.context.Context;
 import org.activiti.engine.impl.pvm.process.ActivityImpl;
 import org.activiti.engine.impl.pvm.process.ScopeImpl;
 
@@ -59,6 +61,11 @@ public class AtomicOperationDeleteCascadeFireActivityEnd extends AbstractEventAt
       }
  
       execution.remove();
+      
+      if(Context.getProcessEngineConfiguration() != null && Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
+      	Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
+      			ActivitiEventBuilder.createEntityEvent(ActivitiEventType.ENTITY_DELETED, execution));
+      }
 
       if (!execution.isDeleteRoot()) {
         InterpretableExecution parent = (InterpretableExecution) execution.getParent();

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/ActivityEventsTest.java

+/* Licensed 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.
+ */
+package org.activiti.engine.test.api.event;
+
+import java.util.Collections;
+
+import org.activiti.engine.delegate.event.ActivitiActivityEvent;
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiMessageEvent;
+import org.activiti.engine.delegate.event.ActivitiSignalEvent;
+import org.activiti.engine.impl.test.PluggableActivitiTestCase;
+import org.activiti.engine.runtime.Execution;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
+import org.activiti.engine.test.Deployment;
+
+/**
+ * Test case for all {@link ActivitiEvent}s related to activities.
+ * 
+ * @author Frederik Heremans
+ */
+public class ActivityEventsTest extends PluggableActivitiTestCase {
+
+	private TestActivitiActivityEventListener listener;
+
+	/**
+	 * Test events related to signalling
+	 */
+	@Deployment
+	public void testActivitySignalEvents() throws Exception {
+		// Two paths are active in the process, one receive-task and one
+		// intermediate catching signal-event
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("signalProcess");
+		assertNotNull(processInstance);
+
+		// Check regular signal through API
+		Execution executionWithSignal = runtimeService.createExecutionQuery().activityId("receivePayment").singleResult();
+		assertNotNull(executionWithSignal);
+
+		runtimeService.signal(executionWithSignal.getId());
+		assertEquals(1, listener.getEventsReceived().size());
+		assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiSignalEvent);
+		ActivitiSignalEvent signalEvent = (ActivitiSignalEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ACTIVITY_SIGNALLED, signalEvent.getType());
+		assertEquals("receivePayment", signalEvent.getActivityId());
+		assertEquals(executionWithSignal.getId(), signalEvent.getExecutionId());
+		assertEquals(executionWithSignal.getProcessInstanceId(), signalEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), signalEvent.getProcessDefinitionId());
+		assertNull(signalEvent.getSignalName());
+		assertNull(signalEvent.getSignalData());
+		listener.clearEventsReceived();
+
+		// Check signal using event, and pass in additional payload
+		Execution executionWithSignalEvent = runtimeService.createExecutionQuery().activityId("shipOrder").singleResult();
+		runtimeService.signalEventReceived("alert", executionWithSignalEvent.getId(),
+		    Collections.singletonMap("test", (Object) "test"));
+		assertEquals(1, listener.getEventsReceived().size());
+		assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiSignalEvent);
+		signalEvent = (ActivitiSignalEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ACTIVITY_SIGNALLED, signalEvent.getType());
+		assertEquals("shipOrder", signalEvent.getActivityId());
+		assertEquals(executionWithSignalEvent.getId(), signalEvent.getExecutionId());
+		assertEquals(executionWithSignalEvent.getProcessInstanceId(), signalEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), signalEvent.getProcessDefinitionId());
+		assertEquals("alert", signalEvent.getSignalName());
+		assertNotNull(signalEvent.getSignalData());
+		listener.clearEventsReceived();
+	}
+
+	/**
+	 * Test to verify if signals coming from an intermediate throw-event trigger
+	 * the right events to be dispatched.
+	 */
+	@Deployment
+	public void testActivitySignalEventsWithinProcess() throws Exception {
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("signalProcess");
+		assertNotNull(processInstance);
+
+		Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+		assertNotNull(task);
+
+		Execution executionWithSignalEvent = runtimeService.createExecutionQuery().activityId("shipOrder").singleResult();
+
+		taskService.complete(task.getId());
+		assertEquals(1L, listener.getEventsReceived().size());
+
+		assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiSignalEvent);
+		ActivitiSignalEvent signalEvent = (ActivitiSignalEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ACTIVITY_SIGNALLED, signalEvent.getType());
+		assertEquals("shipOrder", signalEvent.getActivityId());
+		assertEquals(executionWithSignalEvent.getId(), signalEvent.getExecutionId());
+		assertEquals(executionWithSignalEvent.getProcessInstanceId(), signalEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), signalEvent.getProcessDefinitionId());
+		assertEquals("alert", signalEvent.getSignalName());
+		assertNull(signalEvent.getSignalData());
+	}
+
+	/**
+	 * Test events related to message events, called from the API.
+	 */
+	@Deployment
+	public void testActivityMessageEvents() throws Exception {
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("messageProcess");
+		assertNotNull(processInstance);
+
+		Execution executionWithMessage = runtimeService.createExecutionQuery().activityId("shipOrder").singleResult();
+		assertNotNull(executionWithMessage);
+
+		runtimeService.messageEventReceived("messageName", executionWithMessage.getId());
+		assertEquals(2, listener.getEventsReceived().size());
+
+		// First, a message-event is expected
+		assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiMessageEvent);
+		ActivitiMessageEvent messageEvent = (ActivitiMessageEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, messageEvent.getType());
+		assertEquals("shipOrder", messageEvent.getActivityId());
+		assertEquals(executionWithMessage.getId(), messageEvent.getExecutionId());
+		assertEquals(executionWithMessage.getProcessInstanceId(), messageEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), messageEvent.getProcessDefinitionId());
+		assertEquals("messageName", messageEvent.getMessageName());
+		assertNull(messageEvent.getMessageData());
+
+		// Next, an signal-event is expected, as a result of the message
+		assertTrue(listener.getEventsReceived().get(1) instanceof ActivitiSignalEvent);
+		ActivitiSignalEvent signalEvent = (ActivitiSignalEvent) listener.getEventsReceived().get(1);
+		assertEquals(ActivitiEventType.ACTIVITY_SIGNALLED, signalEvent.getType());
+		assertEquals("shipOrder", signalEvent.getActivityId());
+		assertEquals(executionWithMessage.getId(), signalEvent.getExecutionId());
+		assertEquals(executionWithMessage.getProcessInstanceId(), signalEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), signalEvent.getProcessDefinitionId());
+		assertEquals("messageName", signalEvent.getSignalName());
+		assertNull(signalEvent.getSignalData());
+	}
+
+	/**
+	 * Test events related to message events, called from the API, targeting an event-subprocess.
+	 */
+	@Deployment
+	public void testActivityMessageEventsInEventSubprocess() throws Exception {
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("messageProcess");
+		assertNotNull(processInstance);
+
+		Execution executionWithMessage = runtimeService.createExecutionQuery().activityId("shipOrder").singleResult();
+		assertNotNull(executionWithMessage);
+
+		runtimeService.messageEventReceived("messageName", executionWithMessage.getId());
+
+		// Only a message-event should be present, no signal-event, since the
+		// event-subprocess is
+		// not signaled, but executed instead
+		assertEquals(1, listener.getEventsReceived().size());
+
+		// A message-event is expected
+		assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiMessageEvent);
+		ActivitiMessageEvent messageEvent = (ActivitiMessageEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ACTIVITY_MESSAGE_RECEIVED, messageEvent.getType());
+		assertEquals("catchMessage", messageEvent.getActivityId());
+		assertEquals(executionWithMessage.getId(), messageEvent.getExecutionId());
+		assertEquals(executionWithMessage.getProcessInstanceId(), messageEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), messageEvent.getProcessDefinitionId());
+		assertEquals("messageName", messageEvent.getMessageName());
+		assertNull(messageEvent.getMessageData());
+	}
+	
+	/**
+	 * Test events related to compensation events.
+	 */
+	@Deployment
+	public void testActivityCompensationEvents() throws Exception {
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("compensationProcess");
+		assertNotNull(processInstance);
+
+		Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
+				.singleResult();
+		assertNotNull(task);
+		
+		// Complete task, next a compensation event will be thrown
+		taskService.complete(task.getId());
+		
+		assertEquals(2, listener.getEventsReceived().size());
+
+		// A compensate-event is expected
+		assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiActivityEvent);
+		ActivitiActivityEvent activityEvent = (ActivitiActivityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ACTIVITY_COMPENSATE, activityEvent.getType());
+		assertEquals("compensate", activityEvent.getActivityId());
+		// A new execution is created for the compensation-event, this should be visible in the event
+		assertFalse(processInstance.getId().equals(activityEvent.getExecutionId()));
+		assertEquals(processInstance.getProcessInstanceId(), activityEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), activityEvent.getProcessDefinitionId());
+		
+		// Also, a signal-event is received, representing the boundary-event being executed.
+		assertTrue(listener.getEventsReceived().get(1) instanceof ActivitiSignalEvent);
+		ActivitiSignalEvent signalEvent = (ActivitiSignalEvent) listener.getEventsReceived().get(1);
+		assertEquals(ActivitiEventType.ACTIVITY_SIGNALLED, signalEvent.getType());
+		assertEquals("throwCompensation", signalEvent.getActivityId());
+		assertEquals(processInstance.getId(), signalEvent.getExecutionId());
+		assertEquals(processInstance.getProcessInstanceId(), signalEvent.getProcessInstanceId());
+		assertEquals(processInstance.getProcessDefinitionId(), signalEvent.getProcessDefinitionId());
+		assertEquals("compensationDone", signalEvent.getSignalName());
+		assertNull(signalEvent.getSignalData());
+	}
+
+	@Override
+	protected void initializeServices() {
+		super.initializeServices();
+
+		listener = new TestActivitiActivityEventListener();
+		processEngineConfiguration.getEventDispatcher().addEventListener(listener);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+
+		if (listener != null) {
+			listener.clearEventsReceived();
+			processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
+		}
+	}
+}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/DeploymentEventsTest.java

@@ -14,7 +14,7 @@ package org.activiti.engine.test.api.event;
 
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.impl.test.PluggableActivitiTestCase;
 import org.activiti.engine.repository.Deployment;
 
@@ -41,9 +41,9 @@ public class DeploymentEventsTest extends PluggableActivitiTestCase {
 			
 			// Check create-event
 			assertEquals(1, listener.getEventsReceived().size());
-			assertTrue(listener.getEventsReceived().get(0) instanceof ActivityEntityEvent);
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
 			
-			ActivityEntityEvent event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
 			assertEquals(deployment.getId(), ((Deployment) event.getEntity()).getId());
 			listener.clearEventsReceived();
@@ -51,9 +51,9 @@ public class DeploymentEventsTest extends PluggableActivitiTestCase {
 			// Check update event when category is updated
 			repositoryService.setDeploymentCategory(deployment.getId(), "test");
 			assertEquals(1, listener.getEventsReceived().size());
-			assertTrue(listener.getEventsReceived().get(0) instanceof ActivityEntityEvent);
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
 			
-			event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
 			assertEquals(deployment.getId(), ((Deployment) event.getEntity()).getId());
 			assertEquals("test", ((Deployment) event.getEntity()).getCategory());
@@ -62,9 +62,9 @@ public class DeploymentEventsTest extends PluggableActivitiTestCase {
 		  // Check delete event when category is updated
 			repositoryService.deleteDeployment(deployment.getId(), true);
 			assertEquals(1, listener.getEventsReceived().size());
-			assertTrue(listener.getEventsReceived().get(0) instanceof ActivityEntityEvent);
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
 			
-			event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
 			assertEquals(deployment.getId(), ((Deployment) event.getEntity()).getId());
 			listener.clearEventsReceived();

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/ExecutionEventsTest.java

+/* Licensed 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.
+ */
+package org.activiti.engine.test.api.event;
+
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
+import org.activiti.engine.impl.test.PluggableActivitiTestCase;
+import org.activiti.engine.runtime.Execution;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.test.Deployment;
+
+/**
+ * Test case for all {@link ActivitiEvent}s related to executions.
+ * 
+ * @author Frederik Heremans
+ */
+public class ExecutionEventsTest extends PluggableActivitiTestCase {
+
+	private TestActivitiEntityEventListener listener;
+	
+	/**
+	 * Test create, update and delete events of process instances.
+	 */
+	@Deployment(resources= {"org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml"})
+	public void testExecutionEvents() throws Exception {
+			ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
+			
+			assertNotNull(processInstance);
+			
+			// Check create-event
+			assertEquals(1, listener.getEventsReceived().size());
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
+			
+			ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+			assertEquals(processInstance.getId(), ((Execution) event.getEntity()).getId());
+			listener.clearEventsReceived();
+			
+			// Check update event when suspended/activated
+			runtimeService.suspendProcessInstanceById(processInstance.getId());
+			runtimeService.activateProcessInstanceById(processInstance.getId());
+			
+			assertEquals(2, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(processInstance.getId(), ((Execution) event.getEntity()).getId());
+			assertEquals(ActivitiEventType.ENTITY_SUSPENDED, event.getType());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+			assertEquals(ActivitiEventType.ENTITY_ACTIVATED, event.getType());
+			assertEquals(processInstance.getId(), ((Execution) event.getEntity()).getId());
+			listener.clearEventsReceived();
+			
+			// Check update event when process-definition is supended (should cascade suspend/activate all process instances)
+			repositoryService.suspendProcessDefinitionById(processInstance.getProcessDefinitionId(), true, null);
+			repositoryService.activateProcessDefinitionById(processInstance.getProcessDefinitionId(), true, null);
+			
+			assertEquals(2, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(ActivitiEventType.ENTITY_SUSPENDED, event.getType());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+			assertEquals(ActivitiEventType.ENTITY_ACTIVATED, event.getType());
+			assertEquals(processInstance.getId(), ((Execution) event.getEntity()).getId());
+			listener.clearEventsReceived();
+			
+			// Check update-event when business-key is updated
+			runtimeService.updateBusinessKey(processInstance.getId(), "thekey");
+			assertEquals(1, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(processInstance.getId(), ((Execution) event.getEntity()).getId());
+			assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
+			listener.clearEventsReceived();
+			
+			runtimeService.deleteProcessInstance(processInstance.getId(), "Testing events");
+			
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+			assertEquals(processInstance.getId(), ((Execution) event.getEntity()).getId());
+			listener.clearEventsReceived();
+	}
+	
+	
+	@Override
+	protected void initializeServices() {
+	  super.initializeServices();
+	  
+	  listener = new TestActivitiEntityEventListener(Execution.class);
+	  processEngineConfiguration.getEventDispatcher().addEventListener(listener);
+	}
+	
+	@Override
+	protected void tearDown() throws Exception {
+	  super.tearDown();
+	  
+	  if(listener != null) {
+	  	listener.clearEventsReceived();
+	  	processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
+	  }
+	}
+}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/IdentityLinkEventsTest.java

+/* Licensed 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.
+ */
+package org.activiti.engine.test.api.event;
+
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.impl.test.PluggableActivitiTestCase;
+import org.activiti.engine.repository.ProcessDefinition;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.IdentityLink;
+import org.activiti.engine.task.Task;
+import org.activiti.engine.test.Deployment;
+
+/**
+ * Test case for all {@link ActivitiEvent}s related to process definitions.
+ * 
+ * @author Frederik Heremans
+ */
+public class IdentityLinkEventsTest extends PluggableActivitiTestCase {
+
+	private TestActivitiEntityEventListener listener;
+
+	/**
+	 * Check identity links on process definitions. 
+	 */
+	@Deployment(resources = { "org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml" })
+	public void testProcessDefinitionIdentityLinkEvents() throws Exception {
+		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
+		    .processDefinitionKey("oneTaskProcess").singleResult();
+
+		assertNotNull(processDefinition);
+
+		// Add candidate user and group
+		repositoryService.addCandidateStarterUser(processDefinition.getId(), "kermit");
+		repositoryService.addCandidateStarterGroup(processDefinition.getId(), "sales");
+		assertEquals(2, listener.getEventsReceived().size());
+
+		ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		assertEquals(processDefinition.getId(), event.getProcessDefinitionId());
+		assertNull(event.getProcessInstanceId());
+		assertNull(event.getExecutionId());
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+		assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		assertEquals(processDefinition.getId(), event.getProcessDefinitionId());
+		assertNull(event.getProcessInstanceId());
+		assertNull(event.getExecutionId());
+		listener.clearEventsReceived();
+
+		// Delete identity links
+		repositoryService.deleteCandidateStarterUser(processDefinition.getId(), "kermit");
+		repositoryService.deleteCandidateStarterGroup(processDefinition.getId(), "sales");
+		assertEquals(2, listener.getEventsReceived().size());
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		assertEquals(processDefinition.getId(), event.getProcessDefinitionId());
+		assertNull(event.getProcessInstanceId());
+		assertNull(event.getExecutionId());
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+		assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		assertEquals(processDefinition.getId(), event.getProcessDefinitionId());
+		assertNull(event.getProcessInstanceId());
+		assertNull(event.getExecutionId());
+	}
+	
+	/**
+	 * Check identity links on process instances. 
+	 */
+	@Deployment(resources = { "org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml" })
+	public void testProcessInstanceIdentityLinkEvents() throws Exception {
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
+
+		// Add identity link
+		runtimeService.addUserIdentityLink(processInstance.getId(), "kermit", "test");
+		assertEquals(1, listener.getEventsReceived().size());
+
+		ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		assertEquals(processInstance.getId(), event.getProcessInstanceId());
+		assertEquals(processInstance.getId(), event.getExecutionId());
+		assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+		IdentityLink link = (IdentityLink) event.getEntity();
+		assertEquals("kermit", link.getUserId());
+		assertEquals("test", link.getType());
+		
+		listener.clearEventsReceived();
+
+		// Deleting process should delete identity link
+		runtimeService.deleteProcessInstance(processInstance.getId(), "test");
+		assertEquals(1, listener.getEventsReceived().size());
+
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		link = (IdentityLink) event.getEntity();
+		assertEquals("kermit", link.getUserId());
+		assertEquals("test", link.getType());
+	}
+	
+	/**
+	 * Check identity links on process instances. 
+	 */
+	@Deployment(resources = { "org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml" })
+	public void testTaskIdentityLinks() throws Exception {
+		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
+
+		Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId())
+				.singleResult();
+		assertNotNull(task);
+		
+		// Add identity link
+		taskService.addCandidateUser(task.getId(), "kermit");
+		taskService.addCandidateGroup(task.getId(), "sales");
+		
+		// Three events are received, since the user link on the task also creates an involvment in the process
+		assertEquals(3, listener.getEventsReceived().size());
+
+		ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		IdentityLink link = (IdentityLink) event.getEntity();
+		assertEquals("kermit", link.getUserId());
+		assertEquals("candidate", link.getType());
+		assertEquals(task.getId(), link.getTaskId());
+		assertEquals(task.getExecutionId(), event.getExecutionId());
+		assertEquals(task.getProcessDefinitionId(), event.getProcessDefinitionId());
+		assertEquals(task.getProcessInstanceId(), event.getProcessInstanceId());
+		
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(2);
+		assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+		assertTrue(event.getEntity() instanceof IdentityLink);
+		link = (IdentityLink) event.getEntity();
+		assertEquals("sales", link.getGroupId());
+		assertEquals("candidate", link.getType());
+		assertEquals(task.getId(), link.getTaskId());
+		assertEquals(task.getExecutionId(), event.getExecutionId());
+		assertEquals(task.getProcessDefinitionId(), event.getProcessDefinitionId());
+		assertEquals(task.getProcessInstanceId(), event.getProcessInstanceId());
+		
+		listener.clearEventsReceived();
+
+		// Deleting process should delete identity link
+		runtimeService.deleteProcessInstance(processInstance.getId(), "test");
+		assertEquals(3, listener.getEventsReceived().size());
+
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+		assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+		assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+		event = (ActivitiEntityEvent) listener.getEventsReceived().get(2);
+		assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+	}
+	
+
+	@Override
+	protected void initializeServices() {
+		super.initializeServices();
+
+		listener = new TestActivitiEntityEventListener(IdentityLink.class);
+		processEngineConfiguration.getEventDispatcher().addEventListener(listener);
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+
+		if (listener != null) {
+			listener.clearEventsReceived();
+			processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
+		}
+	}
+}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/JobEventsTest.java

@@ -16,7 +16,7 @@ import java.util.Calendar;
 
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.impl.test.PluggableActivitiTestCase;
 import org.activiti.engine.impl.util.ClockUtil;
 import org.activiti.engine.runtime.Job;
@@ -54,7 +54,7 @@ public class JobEventsTest extends PluggableActivitiTestCase {
 		assertEquals(1, listener.getEventsReceived().size());
 		event = listener.getEventsReceived().get(0);
 		assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
-		Job updatedJob = (Job) ((ActivityEntityEvent) event).getEntity();
+		Job updatedJob = (Job) ((ActivitiEntityEvent) event).getEntity();
 		assertEquals(5, updatedJob.getRetries());
 		checkEventContext(event, theJob, true);
 		
@@ -125,7 +125,7 @@ public class JobEventsTest extends PluggableActivitiTestCase {
 		
 		event = listener.getEventsReceived().get(3);
 		assertEquals(ActivitiEventType.JOB_RETRIES_DECREMENTED, event.getType());
-		assertEquals(0, ((Job) ((ActivityEntityEvent) event).getEntity()).getRetries());
+		assertEquals(0, ((Job) ((ActivitiEntityEvent) event).getEntity()).getRetries());
 		checkEventContext(event, theJob, true);
 	}
 	
@@ -138,8 +138,8 @@ public class JobEventsTest extends PluggableActivitiTestCase {
 			assertEquals(entity.getProcessInstanceId(), event.getExecutionId());
 		}
 		
-		assertTrue(event instanceof ActivityEntityEvent);
-		ActivityEntityEvent entityEvent = (ActivityEntityEvent) event;
+		assertTrue(event instanceof ActivitiEntityEvent);
+		ActivitiEntityEvent entityEvent = (ActivitiEntityEvent) event;
 		assertTrue(entityEvent.getEntity() instanceof Job);
 		assertEquals(entity.getId(), ((Job) entityEvent.getEntity()).getId());
 	}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/ModelEventsTest.java

@@ -14,7 +14,7 @@ package org.activiti.engine.test.api.event;
 
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.impl.test.PluggableActivitiTestCase;
 import org.activiti.engine.repository.Model;
 
@@ -41,7 +41,7 @@ public class ModelEventsTest extends PluggableActivitiTestCase {
 			// Check create event
 			assertEquals(1, listener.getEventsReceived().size());
 			assertEquals(ActivitiEventType.ENTITY_CREATED, listener.getEventsReceived().get(0).getType());
-			assertEquals(model.getId(), ((Model) ((ActivityEntityEvent) listener.getEventsReceived().get(0)).getEntity()).getId());
+			assertEquals(model.getId(), ((Model) ((ActivitiEntityEvent) listener.getEventsReceived().get(0)).getEntity()).getId());
 			listener.clearEventsReceived();
 			
 			// Update model
@@ -50,7 +50,7 @@ public class ModelEventsTest extends PluggableActivitiTestCase {
 			repositoryService.saveModel(model);
 			assertEquals(1, listener.getEventsReceived().size());
 			assertEquals(ActivitiEventType.ENTITY_UPDATED, listener.getEventsReceived().get(0).getType());
-			assertEquals(model.getId(), ((Model) ((ActivityEntityEvent) listener.getEventsReceived().get(0)).getEntity()).getId());
+			assertEquals(model.getId(), ((Model) ((ActivitiEntityEvent) listener.getEventsReceived().get(0)).getEntity()).getId());
 			listener.clearEventsReceived();
 			
 			// Test additional update-methods (source and extra-source)
@@ -65,7 +65,7 @@ public class ModelEventsTest extends PluggableActivitiTestCase {
 			repositoryService.deleteModel(model.getId());
 			assertEquals(1, listener.getEventsReceived().size());
 			assertEquals(ActivitiEventType.ENTITY_DELETED, listener.getEventsReceived().get(0).getType());
-			assertEquals(model.getId(), ((Model) ((ActivityEntityEvent) listener.getEventsReceived().get(0)).getEntity()).getId());
+			assertEquals(model.getId(), ((Model) ((ActivitiEntityEvent) listener.getEventsReceived().get(0)).getEntity()).getId());
 			listener.clearEventsReceived();
 			
 		} finally {

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/ProcessDefinitionEventsTest.java

@@ -12,12 +12,11 @@
  */
 package org.activiti.engine.test.api.event;
 
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
 import org.activiti.engine.impl.test.PluggableActivitiTestCase;
 import org.activiti.engine.repository.ProcessDefinition;
-import org.activiti.engine.task.IdentityLink;
 import org.activiti.engine.test.Deployment;
 
 /**
@@ -28,10 +27,9 @@ import org.activiti.engine.test.Deployment;
 public class ProcessDefinitionEventsTest extends PluggableActivitiTestCase {
 
 	private TestActivitiEntityEventListener listener;
-	private TestActivitiEntityEventListener identityLinkListener;
 	
 	/**
-	 * Test create, update and delete events of deployment entities.
+	 * Test create, update and delete events of process definitions.
 	 */
 	@Deployment(resources= {"org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml"})
 	public void testProcessDefinitionEvents() throws Exception {
@@ -43,9 +41,9 @@ public class ProcessDefinitionEventsTest extends PluggableActivitiTestCase {
 			
 			// Check create-event
 			assertEquals(1, listener.getEventsReceived().size());
-			assertTrue(listener.getEventsReceived().get(0) instanceof ActivityEntityEvent);
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
 			
-			ActivityEntityEvent event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
 			assertEquals(processDefinition.getId(), ((ProcessDefinition) event.getEntity()).getId());
 			listener.clearEventsReceived();
@@ -53,9 +51,9 @@ public class ProcessDefinitionEventsTest extends PluggableActivitiTestCase {
 			// Check update event when category is updated
 			repositoryService.setProcessDefinitionCategory(processDefinition.getId(), "test");
 			assertEquals(1, listener.getEventsReceived().size());
-			assertTrue(listener.getEventsReceived().get(0) instanceof ActivityEntityEvent);
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
 			
-			event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
 			assertEquals(processDefinition.getId(), ((ProcessDefinition) event.getEntity()).getId());
 			assertEquals("test", ((ProcessDefinition) event.getEntity()).getCategory());
@@ -66,10 +64,10 @@ public class ProcessDefinitionEventsTest extends PluggableActivitiTestCase {
 			repositoryService.activateProcessDefinitionById(processDefinition.getId());
 			
 			assertEquals(2, listener.getEventsReceived().size());
-			event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(processDefinition.getId(), ((ProcessDefinition) event.getEntity()).getId());
 			assertEquals(ActivitiEventType.ENTITY_SUSPENDED, event.getType());
-			event = (ActivityEntityEvent) listener.getEventsReceived().get(1);
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
 			assertEquals(ActivitiEventType.ENTITY_ACTIVATED, event.getType());
 			assertEquals(processDefinition.getId(), ((ProcessDefinition) event.getEntity()).getId());
 			listener.clearEventsReceived();
@@ -79,55 +77,20 @@ public class ProcessDefinitionEventsTest extends PluggableActivitiTestCase {
 			deploymentId = null;
 			
 			assertEquals(1, listener.getEventsReceived().size());
-			assertTrue(listener.getEventsReceived().get(0) instanceof ActivityEntityEvent);
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
 			
-			event = (ActivityEntityEvent) listener.getEventsReceived().get(0);
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
 			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
 			assertEquals(processDefinition.getId(), ((ProcessDefinition) event.getEntity()).getId());
 			listener.clearEventsReceived();
 	}
 	
-	@Deployment(resources= {"org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml"})
-	public void testProcessDefinitionIdentityLinkEvents() throws Exception {
-			ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
-					.processDefinitionKey("oneTaskProcess")
-					.singleResult();
-			
-			assertNotNull(processDefinition);
-			
-			// Add candidate user and group
-			repositoryService.addCandidateStarterUser(processDefinition.getId(), "kermit");
-			repositoryService.addCandidateStarterGroup(processDefinition.getId(), "sales");
-			assertEquals(2, identityLinkListener.getEventsReceived().size());
-			
-			ActivityEntityEvent event = (ActivityEntityEvent) identityLinkListener.getEventsReceived().get(0);
-			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
-			assertTrue(event.getEntity() instanceof IdentityLink);
-			event = (ActivityEntityEvent) identityLinkListener.getEventsReceived().get(1);
-			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
-			assertTrue(event.getEntity() instanceof IdentityLink);
-			identityLinkListener.clearEventsReceived();
-			
-			// Delete identity links
-			repositoryService.deleteCandidateStarterUser(processDefinition.getId(), "kermit");
-			repositoryService.deleteCandidateStarterGroup(processDefinition.getId(), "sales");
-			assertEquals(2, identityLinkListener.getEventsReceived().size());
-			event = (ActivityEntityEvent) identityLinkListener.getEventsReceived().get(0);
-			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
-			assertTrue(event.getEntity() instanceof IdentityLink);
-			event = (ActivityEntityEvent) identityLinkListener.getEventsReceived().get(1);
-			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
-			assertTrue(event.getEntity() instanceof IdentityLink);
-	}
-	
 	@Override
 	protected void initializeServices() {
 	  super.initializeServices();
 	  
 	  listener = new TestActivitiEntityEventListener(ProcessDefinition.class);
-	  identityLinkListener = new TestActivitiEntityEventListener(IdentityLink.class);
 	  processEngineConfiguration.getEventDispatcher().addEventListener(listener);
-	  processEngineConfiguration.getEventDispatcher().addEventListener(identityLinkListener);
 	}
 	
 	@Override
@@ -135,10 +98,8 @@ public class ProcessDefinitionEventsTest extends PluggableActivitiTestCase {
 	  super.tearDown();
 	  
 	  if(listener != null) {
-	  	identityLinkListener.clearEventsReceived();
 	  	listener.clearEventsReceived();
 	  	processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
-	  	processEngineConfiguration.getEventDispatcher().removeEventListener(identityLinkListener);
 	  }
 	}
 }

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/ProcessInstanceEventsTest.java

+/* Licensed 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.
+ */
+package org.activiti.engine.test.api.event;
+
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventType;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
+import org.activiti.engine.impl.test.PluggableActivitiTestCase;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.test.Deployment;
+
+/**
+ * Test case for all {@link ActivitiEvent}s related to process instances.
+ * 
+ * @author Frederik Heremans
+ */
+public class ProcessInstanceEventsTest extends PluggableActivitiTestCase {
+
+	private TestActivitiEntityEventListener listener;
+	
+	/**
+	 * Test create, update and delete events of process instances.
+	 */
+	@Deployment(resources= {"org/activiti/engine/test/api/runtime/oneTaskProcess.bpmn20.xml"})
+	public void testProcessInstanceEvents() throws Exception {
+			ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
+			
+			assertNotNull(processInstance);
+			
+			// Check create-event
+			assertEquals(1, listener.getEventsReceived().size());
+			assertTrue(listener.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
+			
+			ActivitiEntityEvent event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_CREATED, event.getType());
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			listener.clearEventsReceived();
+			
+			// Check update event when suspended/activated
+			runtimeService.suspendProcessInstanceById(processInstance.getId());
+			runtimeService.activateProcessInstanceById(processInstance.getId());
+			
+			assertEquals(2, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(ActivitiEventType.ENTITY_SUSPENDED, event.getType());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+			assertEquals(ActivitiEventType.ENTITY_ACTIVATED, event.getType());
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			listener.clearEventsReceived();
+			
+			// Check update event when process-definition is supended (should cascade suspend/activate all process instances)
+			repositoryService.suspendProcessDefinitionById(processInstance.getProcessDefinitionId(), true, null);
+			repositoryService.activateProcessDefinitionById(processInstance.getProcessDefinitionId(), true, null);
+			
+			assertEquals(2, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(ActivitiEventType.ENTITY_SUSPENDED, event.getType());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(1);
+			assertEquals(ActivitiEventType.ENTITY_ACTIVATED, event.getType());
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			listener.clearEventsReceived();
+			
+			// Check update-event when business-key is updated
+			runtimeService.updateBusinessKey(processInstance.getId(), "thekey");
+			assertEquals(1, listener.getEventsReceived().size());
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(ActivitiEventType.ENTITY_UPDATED, event.getType());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			listener.clearEventsReceived();
+			
+			runtimeService.deleteProcessInstance(processInstance.getId(), "Testing events");
+			
+			event = (ActivitiEntityEvent) listener.getEventsReceived().get(0);
+			assertEquals(ActivitiEventType.ENTITY_DELETED, event.getType());
+			assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
+			assertEquals(processInstance.getId(), event.getProcessInstanceId());
+			assertEquals(processInstance.getId(), event.getExecutionId());
+			assertEquals(processInstance.getProcessDefinitionId(), event.getProcessDefinitionId());
+			listener.clearEventsReceived();
+	}
+	
+	
+	@Override
+	protected void initializeServices() {
+	  super.initializeServices();
+	  
+	  listener = new TestActivitiEntityEventListener(ProcessInstance.class);
+	  processEngineConfiguration.getEventDispatcher().addEventListener(listener);
+	}
+	
+	@Override
+	protected void tearDown() throws Exception {
+	  super.tearDown();
+	  
+	  if(listener != null) {
+	  	listener.clearEventsReceived();
+	  	processEngineConfiguration.getEventDispatcher().removeEventListener(listener);
+	  }
+	}
+}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/TestActivitiActivityEventListener.java

+/* Licensed 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.
+ */
+package org.activiti.engine.test.api.event;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.activiti.engine.delegate.event.ActivitiActivityEvent;
+import org.activiti.engine.delegate.event.ActivitiEvent;
+import org.activiti.engine.delegate.event.ActivitiEventListener;
+
+/**
+ * Test event listener that only records events related to activities ({@link ActivitiActivityEvent}s).
+ *  
+ * @author Frederik Heremans
+ */
+public class TestActivitiActivityEventListener implements ActivitiEventListener {
+
+	private List<ActivitiEvent> eventsReceived;
+	
+	public TestActivitiActivityEventListener() {
+		eventsReceived = new ArrayList<ActivitiEvent>();
+  }
+	
+	public List<ActivitiEvent> getEventsReceived() {
+	  return eventsReceived;
+  }
+	
+	public void clearEventsReceived() {
+		eventsReceived.clear();
+	}
+	
+	@Override
+	public void onEvent(ActivitiEvent event) {
+		if(event instanceof ActivitiActivityEvent) {
+			eventsReceived.add(event);
+		}
+	}
+
+	@Override
+	public boolean isFailOnException() {
+		return false;
+	}
+}

modules/activiti-engine/src/test/java/org/activiti/engine/test/api/event/TestActivitiEntityEventListener.java

@@ -17,7 +17,7 @@ import java.util.List;
 
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventListener;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 
 public class TestActivitiEntityEventListener implements ActivitiEventListener {
 
@@ -40,7 +40,7 @@ public class TestActivitiEntityEventListener implements ActivitiEventListener {
 	
 	@Override
 	public void onEvent(ActivitiEvent event) {
-		if(event instanceof ActivityEntityEvent && entityClass.isAssignableFrom(((ActivityEntityEvent) event).getEntity().getClass())) {
+		if(event instanceof ActivitiEntityEvent && entityClass.isAssignableFrom(((ActivitiEntityEvent) event).getEntity().getClass())) {
 			eventsReceived.add(event);
 		}
 	}

modules/activiti-engine/src/test/java/org/activiti/standalone/event/ProcessDefinitionScopedEventListenerDefinitionTest.java

@@ -19,7 +19,7 @@ import org.activiti.engine.ActivitiException;
 import org.activiti.engine.ActivitiIllegalArgumentException;
 import org.activiti.engine.delegate.event.ActivitiEvent;
 import org.activiti.engine.delegate.event.ActivitiEventType;
-import org.activiti.engine.delegate.event.ActivityEntityEvent;
+import org.activiti.engine.delegate.event.ActivitiEntityEvent;
 import org.activiti.engine.impl.test.ResourceActivitiTestCase;
 import org.activiti.engine.runtime.ProcessInstance;
 import org.activiti.engine.task.Task;
@@ -61,8 +61,8 @@ public class ProcessDefinitionScopedEventListenerDefinitionTest extends Resource
 		}
 		
 		// First event received should be creation of Process-instance
-		assertTrue(testListenerBean.getEventsReceived().get(0) instanceof ActivityEntityEvent);
-		ActivityEntityEvent event = (ActivityEntityEvent) testListenerBean.getEventsReceived().get(0);
+		assertTrue(testListenerBean.getEventsReceived().get(0) instanceof ActivitiEntityEvent);
+		ActivitiEntityEvent event = (ActivitiEntityEvent) testListenerBean.getEventsReceived().get(0);
 		assertTrue(event.getEntity() instanceof ProcessInstance);
 		assertEquals(processInstance.getId(), ((ProcessInstance) event.getEntity()).getId());
 		

modules/activiti-engine/src/test/resources/org/activiti/engine/test/api/event/ActivityEventsTest.testActivityCompensationEvents.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:activiti="http://activiti.org/bpmn" targetNamespace="Examples">
+
+
+  <signal id="shipOrderSignal" name="alert" />
+
+  <process id="compensationProcess">
+
+    <startEvent id="theStart" />
+
+    <sequenceFlow id="flow1" sourceRef="theStart"
+      targetRef="usertask" />
+
+    <userTask id="usertask" />
+
+    <boundaryEvent id="compensateUserTask" attachedToRef="usertask">
+      <compensateEventDefinition />
+    </boundaryEvent>
+
+    <manualTask id="compensate" isForCompensation="true" />
+
+    <sequenceFlow sourceRef="usertask" targetRef="throwCompensation" />
+    <intermediateThrowEvent id="throwCompensation">
+      <compensateEventDefinition />
+    </intermediateThrowEvent>
+    <sequenceFlow sourceRef="throwCompensation" targetRef="secondUserTask" />
+    
+    <userTask id="secondUserTask" />
+    <sequenceFlow sourceRef="secondUserTask" targetRef="theEnd" />
+
+    <endEvent id="theEnd" />
+    <association associationDirection="One" sourceRef="compensateUserTask"
+      targetRef="compensate" id="as1" />
+  </process>
+
+</definitions>

modules/activiti-engine/src/test/resources/org/activiti/engine/test/api/event/ActivityEventsTest.testActivityMessageEvents.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:activiti="http://activiti.org/bpmn" targetNamespace="Examples">
+
+
+  <message id="myMessage" name="messageName" />
+
+  <process id="messageProcess">
+
+    <startEvent id="theStart" />
+    <sequenceFlow sourceRef="theStart" targetRef="shipOrder" />
+
+    <intermediateCatchEvent id="shipOrder" name="On Message">
+      <messageEventDefinition messageRef="myMessage" />
+    </intermediateCatchEvent>
+
+    <sequenceFlow sourceRef="shipOrder" targetRef="theEnd" />
+
+    <endEvent id="theEnd" />
+
+  </process>
+
+</definitions>

modules/activiti-engine/src/test/resources/org/activiti/engine/test/api/event/ActivityEventsTest.testActivityMessageEventsInEventSubprocess.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:activiti="http://activiti.org/bpmn" targetNamespace="Examples">
+
+
+  <message id="myMessage" name="messageName" />
+
+  <process id="messageProcess">
+
+    <startEvent id="theStart" />
+    <sequenceFlow sourceRef="theStart" targetRef="shipOrder" />
+
+    <userTask id="shipOrder" name="Wait" />
+
+    <sequenceFlow sourceRef="shipOrder" targetRef="theEnd" />
+
+    <endEvent id="theEnd" />
+
+    <subProcess id="eventSubProcess" triggeredByEvent="true">
+      <startEvent id="catchMessage">
+        <messageEventDefinition messageRef="myMessage" />
+      </startEvent>
+      <sequenceFlow id="flow2" sourceRef="catchMessage"
+        targetRef="endSubProcess" />
+      <endEvent id="endSubProcess" />
+    </subProcess>
+
+  </process>
+
+
+
+</definitions>

modules/activiti-engine/src/test/resources/org/activiti/engine/test/api/event/ActivityEventsTest.testActivitySignalEvents.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:activiti="http://activiti.org/bpmn" targetNamespace="Examples">
+
+
+  <signal id="shipOrderSignal" name="alert" />
+
+  <process id="signalProcess">
+
+    <startEvent id="theStart" />
+
+    <sequenceFlow id="flow1" sourceRef="theStart"
+      targetRef="fork" />
+
+    <parallelGateway id="fork" />
+    <sequenceFlow sourceRef="fork" targetRef="receivePayment" />
+    <sequenceFlow sourceRef="fork" targetRef="shipOrder" />
+
+    <receiveTask id="receivePayment" name="Receive Payment" />
+    <sequenceFlow sourceRef="receivePayment" targetRef="join" />
+
+    <intermediateCatchEvent id="shipOrder" name="On Alert">
+      <!-- signal event definition -->
+      <signalEventDefinition signalRef="shipOrderSignal" />
+    </intermediateCatchEvent>
+
+    <sequenceFlow sourceRef="shipOrder" targetRef="join" />
+
+    <parallelGateway id="join" />
+    <sequenceFlow sourceRef="join" targetRef="archiveOrder" />
+
+    <userTask id="archiveOrder" name="Archive Order" />
+    <sequenceFlow sourceRef="archiveOrder" targetRef="theEnd" />
+
+    <endEvent id="theEnd" />
+
+  </process>
+
+</definitions>

modules/activiti-engine/src/test/resources/org/activiti/engine/test/api/event/ActivityEventsTest.testActivitySignalEventsWithinProcess.bpmn20.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+  xmlns:activiti="http://activiti.org/bpmn" targetNamespace="Examples">
+
+
+  <signal id="shipOrderSignal" name="alert" />
+
+  <process id="signalProcess">
+
+    <startEvent id="theStart" />
+
+    <sequenceFlow id="flow1" sourceRef="theStart"
+      targetRef="fork" />
+
+    <parallelGateway id="fork" />
+    <sequenceFlow sourceRef="fork" targetRef="usertask" />
+    <sequenceFlow sourceRef="fork" targetRef="shipOrder" />
+
+    <userTask id="usertask" />
+    <sequenceFlow sourceRef="usertask" targetRef="signal" />
+
+    <intermediateThrowEvent id="signal">
+      <signalEventDefinition signalRef="shipOrderSignal" />
+    </intermediateThrowEvent>
+    <sequenceFlow sourceRef="signal" targetRef="join" />
+
+    <intermediateCatchEvent id="shipOrder" name="On Alert">
+      <!-- signal event definition -->
+      <signalEventDefinition signalRef="shipOrderSignal" />
+    </intermediateCatchEvent>
+
+    <sequenceFlow sourceRef="shipOrder" targetRef="join" />
+
+    <parallelGateway id="join" />
+    <sequenceFlow sourceRef="join" targetRef="archiveOrder" />
+
+    <userTask id="archiveOrder" name="Archive Order" />
+    <sequenceFlow sourceRef="archiveOrder" targetRef="theEnd" />
+
+    <endEvent id="theEnd" />
+
+  </process>
+
+</definitions>