[jbpm-commits] JBoss JBPM SVN: r3725 - in jbpm3/trunk/modules/core/src: main/java/org/jbpm/logging/exe and 6 other directories.
do-not-reply at jboss.org
do-not-reply at jboss.org
Wed Jan 28 00:23:56 EST 2009
Author: alex.guizar at jboss.com
Date: 2009-01-28 00:23:55 -0500 (Wed, 28 Jan 2009)
New Revision: 3725
Modified:
jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/db/DbLoggingService.java
jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/exe/LoggingInstance.java
jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/CompositeLog.java
jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/ProcessLog.java
jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CascadeSaveOperation.java
jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CheckUnpersistableVariablesOperation.java
jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/SaveLogsOperation.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ActionLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/NodeLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessInstanceLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessLogsTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/SignalLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/TransitionLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/exe/CompositeLogTest.java
jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/log/ProcessLogDbTest.java
Log:
generalized logging and save operations
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/db/DbLoggingService.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/db/DbLoggingService.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/db/DbLoggingService.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -30,25 +30,23 @@
public class DbLoggingService implements LoggingService {
private static final long serialVersionUID = 1L;
-
+
Session session = null;
-
+
public DbLoggingService() {
- JbpmContext currentJbpmContext = JbpmContext.getCurrentJbpmContext();
- if (currentJbpmContext==null) {
+ JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext();
+ if (jbpmContext == null) {
throw new JbpmException("instantiation of the DbLoggingService requires a current JbpmContext");
}
- session = currentJbpmContext.getSession();
+ session = jbpmContext.getSession();
}
public void log(ProcessLog processLog) {
- if (session!=null) {
- // Improvement suggestions by Max :
- // db-level: use some hilo based id strategy to avoid repetitive insert. (dependent on db-lock)
- // sessionwise: use statelesssession or at least different session
- // can we borrow connection safely. Nag Steve. (open ontop of another session)
- session.save(processLog);
- }
+ // Improvement suggestions by Max :
+ // db-level: use some hilo based id strategy to avoid repetitive insert. (dependent on db-lock)
+ // session-level: use stateless session or at least different session
+ // can we borrow connection safely. Nag Steve. (open on top of another session)
+ session.save(processLog);
}
public void close() {
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/exe/LoggingInstance.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/exe/LoggingInstance.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/exe/LoggingInstance.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -21,118 +21,112 @@
*/
package org.jbpm.logging.exe;
-import java.util.*;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
-import org.apache.commons.logging.*;
-import org.jbpm.graph.log.*;
-import org.jbpm.logging.log.*;
-import org.jbpm.module.exe.*;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.jbpm.logging.log.CompositeLog;
+import org.jbpm.logging.log.ProcessLog;
+import org.jbpm.module.exe.ModuleInstance;
import org.jbpm.util.Clock;
/**
- * non persisted class that collects {@link org.jbpm.logging.log.ProcessLog}s
- * during process execution. When the process instance gets saved, the
- * process logs will be saved by the {@link org.jbpm.db.LoggingSession}.
+ * non persisted class that collects {@link org.jbpm.logging.log.ProcessLog}s during process
+ * execution. When the process instance gets saved, the process logs will be saved by the
+ * {@link org.jbpm.db.LoggingSession}.
*/
public class LoggingInstance extends ModuleInstance {
private static final long serialVersionUID = 1L;
-
- List logs = new ArrayList();
- transient LinkedList compositeLogStack = new LinkedList();
-
+
+ List<ProcessLog> logs = new ArrayList<ProcessLog>();
+ transient List<CompositeLog> compositeLogStack = new ArrayList<CompositeLog>();
+
public LoggingInstance() {
}
-
+
public void startCompositeLog(CompositeLog compositeLog) {
addLog(compositeLog);
- compositeLogStack.addFirst(compositeLog);
+ compositeLogStack.add(compositeLog);
}
-
+
public void endCompositeLog() {
- compositeLogStack.removeFirst();
+ compositeLogStack.remove(compositeLogStack.size() - 1);
}
public void addLog(ProcessLog processLog) {
if (!compositeLogStack.isEmpty()) {
- CompositeLog currentCompositeLog = (CompositeLog) compositeLogStack.getFirst();
+ CompositeLog currentCompositeLog = compositeLogStack.get(compositeLogStack.size() - 1);
processLog.setParent(currentCompositeLog);
currentCompositeLog.addChild(processLog);
}
processLog.setDate(Clock.getCurrentTime());
-
+
logs.add(processLog);
}
-
- public List getLogs() {
+
+ public List<ProcessLog> getLogs() {
return logs;
}
/**
- * get logs, filetered by log type.
+ * get logs, filtered by log type.
*/
- public List getLogs(Class filterClass) {
- return getLogs(logs, filterClass);
+ public <L extends ProcessLog> List<L> getLogs(Class<L> logType) {
+ return getLogs(logs, logType);
}
-
- public static List getLogs(Collection logs, Class filterClass) {
- List filteredLogs = new ArrayList();
- if (logs!=null) {
- Iterator iter = logs.iterator();
- while (iter.hasNext()) {
- Object log = iter.next();
- if (filterClass.isAssignableFrom(log.getClass())) {
- filteredLogs.add(log);
+
+ public static <L extends ProcessLog> List<L> getLogs(Collection<ProcessLog> logs, Class<L> logType) {
+ List<L> filteredLogs = new ArrayList<L>();
+ if (logs != null) {
+ for (ProcessLog log : logs) {
+ if (logType.isInstance(log)) {
+ filteredLogs.add(logType.cast(log));
}
}
}
return filteredLogs;
}
- LinkedList getCompositeLogStack() {
+ List<CompositeLog> getCompositeLogStack() {
return compositeLogStack;
}
- List getCurrentOperationReversedActionLogs() {
- List actionLogs = new ArrayList();
- ProcessLog operationLog = (ProcessLog) compositeLogStack.getFirst();
- ListIterator listIterator = logs.listIterator(logs.size());
- ProcessLog processLog = (ProcessLog) listIterator.previous();
- while ( (listIterator.hasNext())
- && (processLog!=operationLog) ) {
- if (processLog instanceof ActionLog) {
- actionLogs.add(0, processLog);
- }
- }
- return actionLogs;
- }
-
public void logLogs() {
- Iterator iter = logs.iterator();
- while (iter.hasNext()) {
- ProcessLog processLog = (ProcessLog) iter.next();
- if (processLog.getParent()==null) {
- logLog("+-", processLog);
+ for (ProcessLog processLog : logs) {
+ if (processLog.getParent() == null) {
+ logLog("", processLog);
}
}
}
void logLog(String indentation, ProcessLog processLog) {
- log.debug(processLog.getToken()+"["+processLog.getIndex()+"] "+processLog+" on "+processLog.getToken());
- if (processLog instanceof CompositeLog) {
+ boolean isComposite = processLog instanceof CompositeLog;
+ log.debug(indentation
+ + (isComposite ? "+ [" : " [")
+ + processLog.getIndex()
+ + "] "
+ + processLog
+ + " on "
+ + processLog.getToken());
+ if (isComposite) {
CompositeLog compositeLog = (CompositeLog) processLog;
- if (compositeLog.getChildren()!=null) {
- Iterator iter = compositeLog.getChildren().iterator();
- while (iter.hasNext()) {
- logLog("| "+indentation, (ProcessLog) iter.next());
+ List<ProcessLog> children = compositeLog.getChildren();
+ if (children != null) {
+ for (ProcessLog childLog : children) {
+ logLog(indentation + " ", childLog);
}
}
}
}
-
- Object readResolve() {
- compositeLogStack = new LinkedList();
- return this;
+
+ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+ in.defaultReadObject();
+ compositeLogStack = new ArrayList<CompositeLog>();
}
private static final Log log = LogFactory.getLog(LoggingInstance.class);
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/CompositeLog.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/CompositeLog.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/CompositeLog.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -28,15 +28,16 @@
private static final long serialVersionUID = 1L;
- List children = null;
+ List<ProcessLog> children = null;
public CompositeLog() {
}
- public List getChildren() {
+ public List<ProcessLog> getChildren() {
return children;
}
- public void setChildren(List children) {
+
+ public void setChildren(List<ProcessLog> children) {
this.children = children;
}
@@ -45,7 +46,7 @@
}
public void addChild(ProcessLog processLog) {
- if (children==null) children = new ArrayList();
+ if (children == null) children = new ArrayList<ProcessLog>();
children.add(processLog);
}
}
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/ProcessLog.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/ProcessLog.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/logging/log/ProcessLog.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -26,7 +26,7 @@
import org.jbpm.graph.exe.*;
public abstract class ProcessLog implements Serializable {
-
+
private static final long serialVersionUID = 1L;
long id = 0;
@@ -34,25 +34,26 @@
protected Date date = null;
protected Token token = null;
protected CompositeLog parent = null;
-
+
public ProcessLog() {
}
-
+
/**
- * provides a text description for this update
- * which can be used e.g. in the admin web console.
+ * provides a text description for this update which can be used e.g. in the admin web console.
*/
- public abstract String toString();
-
+ public String toString() {
+ return super.toString();
+ }
+
public String getActorId() {
String actorId = null;
- if (parent!=null) {
- // AuthenticationLog overriddes the getActorId
+ if (parent != null) {
+ // AuthenticationLog overrides the getActorId
actorId = parent.getActorId();
}
return actorId;
}
-
+
public void setToken(Token token) {
this.token = token;
this.index = token.nextLogIndex();
@@ -61,28 +62,36 @@
public void setParent(CompositeLog parent) {
this.parent = parent;
}
+
public long getId() {
return id;
}
+
public Date getDate() {
return date;
}
+
public void setDate(Date date) {
this.date = date;
}
+
public CompositeLog getParent() {
return parent;
}
+
public Token getToken() {
return token;
}
+
public void setIndex(int index) {
this.index = index;
}
+
public int getIndex() {
return index;
}
- public List getChildren() {
+
+ public List<ProcessLog> getChildren() {
return null;
}
}
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CascadeSaveOperation.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CascadeSaveOperation.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CascadeSaveOperation.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -23,7 +23,6 @@
import java.util.Collection;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.Set;
import org.apache.commons.logging.Log;
@@ -36,26 +35,27 @@
private static final long serialVersionUID = 1L;
public void save(ProcessInstance processInstance, JbpmContext jbpmContext) {
- log.debug("cascading save of '"+processInstance+"'");
- Set cascadedProcessInstances = new HashSet();
+ log.debug("cascading save of '" + processInstance + "'");
+ Set<ProcessInstance> cascadedProcessInstances = new HashSet<ProcessInstance>();
cascadedProcessInstances.add(processInstance);
- cascadeSave(processInstance.removeCascadeProcessInstances(), jbpmContext, cascadedProcessInstances);
+ cascadeSave(processInstance.removeCascadeProcessInstances(), jbpmContext,
+ cascadedProcessInstances);
}
- void cascadeSave(Collection cascadeProcessInstances, JbpmContext jbpmContext, Set cascadedProcessInstances) {
- if (cascadeProcessInstances!=null) {
- Iterator iter = cascadeProcessInstances.iterator();
- while (iter.hasNext()) {
- ProcessInstance cascadeInstance = (ProcessInstance) iter.next();
+ void cascadeSave(Collection<ProcessInstance> cascadeProcessInstances, JbpmContext jbpmContext,
+ Set<ProcessInstance> cascadedProcessInstances) {
+ if (cascadeProcessInstances != null) {
+ for (ProcessInstance cascadeInstance : cascadeProcessInstances) {
saveCascadeInstance(cascadeInstance, jbpmContext, cascadedProcessInstances);
}
}
}
-
- void saveCascadeInstance(ProcessInstance cascadeInstance, JbpmContext jbpmContext, Set cascadedProcessInstances) {
- if (! cascadedProcessInstances.contains(cascadeInstance)) {
- Collection cascadeProcessInstances = cascadeInstance.removeCascadeProcessInstances();
- log.debug("cascading save to process instance '"+cascadeInstance+"'");
+
+ void saveCascadeInstance(ProcessInstance cascadeInstance, JbpmContext jbpmContext,
+ Set<ProcessInstance> cascadedProcessInstances) {
+ if (!cascadedProcessInstances.contains(cascadeInstance)) {
+ Collection<ProcessInstance> cascadeProcessInstances = cascadeInstance.removeCascadeProcessInstances();
+ log.debug("cascading save to process instance '" + cascadeInstance + "'");
jbpmContext.save(cascadeInstance);
cascadedProcessInstances.add(cascadeInstance);
cascadeSave(cascadeProcessInstances, jbpmContext, cascadedProcessInstances);
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CheckUnpersistableVariablesOperation.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CheckUnpersistableVariablesOperation.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/CheckUnpersistableVariablesOperation.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -22,7 +22,6 @@
package org.jbpm.svc.save;
import java.util.Collection;
-import java.util.Iterator;
import java.util.Map;
import org.jbpm.JbpmContext;
@@ -37,37 +36,41 @@
private static final long serialVersionUID = 1L;
public void save(ProcessInstance processInstance, JbpmContext jbpmContext) {
- Collection updatedVariableContainers = VariableContainer.getUpdatedVariableContainers(processInstance);
- if (updatedVariableContainers!=null) {
+ Collection<VariableContainer> updatedVariableContainers = VariableContainer.getUpdatedVariableContainers(processInstance);
+ if (updatedVariableContainers == null) return;
- // loop over all updated variable containers
- Iterator iter = updatedVariableContainers.iterator();
- while (iter.hasNext()) {
- VariableContainer variableContainer = (VariableContainer) iter.next();
- Map variableInstances = variableContainer.getVariableInstances();
- if (variableInstances!=null) {
+ // loop over all updated variable containers
+ for (VariableContainer variableContainer : updatedVariableContainers) {
+ Map<String, VariableInstance> variableInstances = variableContainer.getVariableInstances();
+ if (variableInstances == null) continue;
- // loop over all variable instances in the container
- Iterator varInstancesIter = variableInstances.entrySet().iterator();
- while (varInstancesIter.hasNext()) {
- Map.Entry entry = (Map.Entry) varInstancesIter.next();
- String name = (String) entry.getKey();
- VariableInstance variableInstance = (VariableInstance) entry.getValue();
+ // loop over all variable instances in the container
+ for (Map.Entry<String, VariableInstance> entry : variableInstances.entrySet()) {
+ VariableInstance variableInstance = entry.getValue();
+ if (!(variableInstance instanceof UnpersistableInstance)) continue;
- // if the variable is of the unpersistable type... booom!
- if (variableInstance instanceof UnpersistableInstance) {
- Object value = variableInstance.getValue();
- if (value!=null) {
- throw new JbpmException("variable '"+name+"' in '"+variableContainer+"' contains '"+value+"': type '"+value.getClass().getName()+"' is unpersistable according to the jbpm.varmapping.xml configuration");
- } else {
- throw new JbpmException("variable '"+name+"' in '"+variableContainer+"' was created with a non persistable value");
- }
- }
- }
+ // the variable is unpersistable... booom!
+ String name = entry.getKey();
+ Object value = variableInstance.getValue();
+ if (value != null) {
+ throw new JbpmException("variable '"
+ + name
+ + "' in "
+ + variableContainer
+ + " contains value '"
+ + value
+ + "': type '"
+ + value.getClass().getName()
+ + "' is not mapped in jbpm.varmapping.xml");
}
+ else {
+ throw new JbpmException("variable '"
+ + name
+ + "' in '"
+ + variableContainer
+ + "' was created with a non persistable value");
+ }
}
}
}
-
- // private static Log log = LogFactory.getLog(CheckUnpersistableVariablesOperation.class);
}
Modified: jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/SaveLogsOperation.java
===================================================================
--- jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/SaveLogsOperation.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/main/java/org/jbpm/svc/save/SaveLogsOperation.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -21,8 +21,6 @@
*/
package org.jbpm.svc.save;
-import java.util.Iterator;
-
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jbpm.JbpmContext;
@@ -37,20 +35,18 @@
public void save(ProcessInstance processInstance, JbpmContext jbpmContext) {
LoggingService loggingService = jbpmContext.getServices().getLoggingService();
-
- if (loggingService!=null) {
+
+ if (loggingService != null) {
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- log.debug("flushing logs to logging service.");
- Iterator iter = loggingInstance.getLogs().iterator();
- while (iter.hasNext()) {
- ProcessLog processLog = (ProcessLog) iter.next();
+ log.debug("posting logs to logging service.");
+ for (ProcessLog processLog : loggingInstance.getLogs()) {
loggingService.log(processLog);
}
-
- } else {
+ }
+ else {
log.debug("ignoring logs. no logging service available.");
}
}
-
+
private static Log log = LogFactory.getLog(SaveLogsOperation.class);
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -23,7 +23,6 @@
import java.util.Arrays;
import java.util.Date;
-import java.util.List;
import org.jbpm.AbstractJbpmTestCase;
import org.jbpm.bytes.ByteArray;
@@ -35,56 +34,52 @@
import org.jbpm.logging.exe.LoggingInstance;
public class VariableLogTest extends AbstractJbpmTestCase {
-
+
private ProcessDefinition processDefinition = null;
private ProcessInstance processInstance = null;
private ContextInstance contextInstance = null;
private LoggingInstance loggingInstance = null;
-
- protected void setUp() throws Exception
- {
+
+ protected void setUp() throws Exception {
super.setUp();
processDefinition = new ProcessDefinition();
processDefinition.addDefinition(new ContextDefinition());
- processInstance = new ProcessInstance( processDefinition );
- contextInstance = (ContextInstance) processInstance.getInstance(ContextInstance.class);
- loggingInstance = (LoggingInstance) processInstance.getInstance(LoggingInstance.class);
+ processInstance = new ProcessInstance(processDefinition);
+ contextInstance = processInstance.getInstance(ContextInstance.class);
+ loggingInstance = processInstance.getInstance(LoggingInstance.class);
}
-
+
public void testVariableCreateLogs() {
contextInstance.setVariable("a", new Integer(3));
- // // contextSession.updateProcessContextVariables(contextInstance);
-
- VariableCreateLog createLog = (VariableCreateLog)loggingInstance.getLogs(VariableCreateLog.class).get(0);
+
+ VariableCreateLog createLog = loggingInstance.getLogs(VariableCreateLog.class).get(0);
assertEquals("a", createLog.getVariableInstance().getName());
-
- LongUpdateLog updateLog = (LongUpdateLog)loggingInstance.getLogs(LongUpdateLog.class).get(0);
+ LongUpdateLog updateLog = loggingInstance.getLogs(LongUpdateLog.class).get(0);
assertNull(updateLog.getOldValue());
assertEquals(new Long(3), updateLog.getNewValue());
}
-
+
public void testByteArrayUpdateLog() {
contextInstance.setVariable("a", "first value".getBytes());
contextInstance.setVariable("a", "second value".getBytes());
-
- // System.out.println(loggingInstance.getLogs());
-
- List logs = loggingInstance.getLogs(VariableUpdateLog.class);
- VariableUpdateLog variableLog = (VariableUpdateLog)logs.get(1);
-
- assertTrue(Arrays.equals("first value".getBytes(), ((ByteArray) variableLog.getOldValue()).getBytes()));
- assertTrue(Arrays.equals("second value".getBytes(), ((ByteArray) variableLog.getNewValue()).getBytes()));
+
+ VariableUpdateLog variableLog = loggingInstance.getLogs(VariableUpdateLog.class).get(1);
+
+ assertTrue(Arrays.equals("first value".getBytes(),
+ ((ByteArray) variableLog.getOldValue()).getBytes()));
+ assertTrue(Arrays.equals("second value".getBytes(),
+ ((ByteArray) variableLog.getNewValue()).getBytes()));
}
public void testDateUpdateLog() {
Date now = new Date();
- Date future = new Date(now.getTime()+5);
+ Date future = new Date(now.getTime() + 5);
contextInstance.setVariable("a", now);
contextInstance.setVariable("a", future);
- VariableUpdateLog variableLog = (VariableUpdateLog)loggingInstance.getLogs(VariableUpdateLog.class).get(1);
-
+ VariableUpdateLog variableLog = loggingInstance.getLogs(VariableUpdateLog.class).get(1);
+
assertEquals(now, variableLog.getOldValue());
assertEquals(future, variableLog.getNewValue());
}
@@ -93,8 +88,8 @@
contextInstance.setVariable("a", new Double(3.3));
contextInstance.setVariable("a", new Double(4.4));
- VariableUpdateLog variableLog = (VariableUpdateLog)loggingInstance.getLogs(VariableUpdateLog.class).get(1);
-
+ VariableUpdateLog variableLog = loggingInstance.getLogs(VariableUpdateLog.class).get(1);
+
assertEquals(new Double(3.3), variableLog.getOldValue());
assertEquals(new Double(4.4), variableLog.getNewValue());
}
@@ -103,7 +98,7 @@
contextInstance.setVariable("a", new Integer(3));
contextInstance.setVariable("a", new Integer(5));
- VariableUpdateLog variableLog = (VariableUpdateLog)loggingInstance.getLogs(VariableUpdateLog.class).get(1);
+ VariableUpdateLog variableLog = loggingInstance.getLogs(VariableUpdateLog.class).get(1);
assertEquals(new Long(3), variableLog.getOldValue());
assertEquals(new Long(5), variableLog.getNewValue());
@@ -113,7 +108,7 @@
contextInstance.setVariable("a", "pope");
contextInstance.setVariable("a", "me");
- VariableUpdateLog variableLog = (VariableUpdateLog)loggingInstance.getLogs(VariableUpdateLog.class).get(1);
+ VariableUpdateLog variableLog = loggingInstance.getLogs(VariableUpdateLog.class).get(1);
assertEquals("pope", variableLog.getOldValue());
assertEquals("me", variableLog.getNewValue());
@@ -123,8 +118,8 @@
contextInstance.setVariable("a", new Integer(3));
contextInstance.deleteVariable("a");
- VariableDeleteLog deleteLog = (VariableDeleteLog)loggingInstance.getLogs(VariableDeleteLog.class).get(0);
-
+ VariableDeleteLog deleteLog = loggingInstance.getLogs(VariableDeleteLog.class).get(0);
+
assertEquals("a", deleteLog.getVariableInstance().getName());
}
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/context/log/VariableUpdateDbTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -33,16 +33,15 @@
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.logging.exe.LoggingInstance;
+import org.jbpm.logging.log.ProcessLog;
import org.jbpm.util.DateDbTestUtil;
-public class VariableUpdateDbTest extends AbstractDbTestCase
-{
+public class VariableUpdateDbTest extends AbstractDbTestCase {
private ProcessDefinition processDefinition;
private ProcessInstance processInstance;
private ContextInstance contextInstance;
- protected void setUp() throws Exception
- {
+ protected void setUp() throws Exception {
super.setUp();
processDefinition = new ProcessDefinition();
processDefinition.addDefinition(new ContextDefinition());
@@ -53,38 +52,36 @@
}
@Override
- protected void tearDown() throws Exception
- {
+ protected void tearDown() throws Exception {
jbpmContext.getGraphSession().deleteProcessDefinition(processDefinition.getId());
super.tearDown();
}
- public void testVariableCreateLogs()
- {
+ public void testVariableCreateLogs() {
contextInstance.setVariable("a", new Integer(3));
jbpmContext.save(processInstance);
newTransaction();
- List logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId());
- VariableCreateLog createLog = (VariableCreateLog)LoggingInstance.getLogs(logs, VariableCreateLog.class).get(0);
+ List<ProcessLog> logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId());
+ VariableCreateLog createLog = LoggingInstance.getLogs(logs, VariableCreateLog.class).get(0);
assertEquals("a", createLog.getVariableInstance().getName());
}
- public void testByteArrayUpdateLog()
- {
+ public void testByteArrayUpdateLog() {
contextInstance.setVariable("a", "first value".getBytes());
jbpmContext.save(processInstance);
contextInstance.setVariable("a", "second value".getBytes());
VariableUpdateLog variableLog = saveAndReloadUpdateLog(processInstance);
- assertTrue(Arrays.equals("first value".getBytes(), ((ByteArray)variableLog.getOldValue()).getBytes()));
- assertTrue(Arrays.equals("second value".getBytes(), ((ByteArray)variableLog.getNewValue()).getBytes()));
+ assertTrue(Arrays.equals("first value".getBytes(),
+ ((ByteArray) variableLog.getOldValue()).getBytes()));
+ assertTrue(Arrays.equals("second value".getBytes(),
+ ((ByteArray) variableLog.getNewValue()).getBytes()));
}
- public void testDateUpdateLog()
- {
+ public void testDateUpdateLog() {
final Date now = Calendar.getInstance().getTime();
final Date future = new Date(now.getTime() + 5);
contextInstance.setVariable("a", now);
@@ -94,12 +91,13 @@
VariableUpdateLog variableLog = saveAndReloadUpdateLog(processInstance);
DateDbTestUtil dbUtilInst = DateDbTestUtil.getInstance();
- assertEquals(dbUtilInst.convertDateToSeconds(now), dbUtilInst.convertDateToSeconds((Date)variableLog.getOldValue()));
- assertEquals(dbUtilInst.convertDateToSeconds(future), dbUtilInst.convertDateToSeconds((Date)variableLog.getNewValue()));
+ assertEquals(dbUtilInst.convertDateToSeconds(now),
+ dbUtilInst.convertDateToSeconds((Date) variableLog.getOldValue()));
+ assertEquals(dbUtilInst.convertDateToSeconds(future),
+ dbUtilInst.convertDateToSeconds((Date) variableLog.getNewValue()));
}
- public void testDoubleUpdateLog()
- {
+ public void testDoubleUpdateLog() {
contextInstance.setVariable("a", new Double(3.3));
jbpmContext.save(processInstance);
contextInstance.setVariable("a", new Double(4.4));
@@ -110,8 +108,7 @@
assertEquals(new Double(4.4), variableLog.getNewValue());
}
- public void testLongUpdateLog()
- {
+ public void testLongUpdateLog() {
contextInstance.setVariable("a", new Integer(3));
jbpmContext.save(processInstance);
contextInstance.setVariable("a", new Integer(5));
@@ -122,8 +119,7 @@
assertEquals(new Long(5), variableLog.getNewValue());
}
- public void testStringUpdateLog()
- {
+ public void testStringUpdateLog() {
contextInstance.setVariable("a", "pope");
jbpmContext.save(processInstance);
contextInstance.setVariable("a", "me");
@@ -134,25 +130,23 @@
assertEquals("me", variableLog.getNewValue());
}
- public void testVariableDeleteLog()
- {
+ public void testVariableDeleteLog() {
contextInstance.setVariable("a", new Integer(3));
jbpmContext.save(processInstance);
contextInstance.deleteVariable("a");
jbpmContext.save(processInstance);
newTransaction();
- List logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId());
- VariableDeleteLog deleteLog = (VariableDeleteLog)LoggingInstance.getLogs(logs, VariableDeleteLog.class).get(0);
+ List<ProcessLog> logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId());
+ VariableDeleteLog deleteLog = LoggingInstance.getLogs(logs, VariableDeleteLog.class).get(0);
assertEquals("a", deleteLog.getVariableInstance().getName());
}
- private VariableUpdateLog saveAndReloadUpdateLog(ProcessInstance processInstance)
- {
+ private VariableUpdateLog saveAndReloadUpdateLog(ProcessInstance processInstance) {
jbpmContext.save(processInstance);
newTransaction();
- List logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId());
- return (VariableUpdateLog)LoggingInstance.getLogs(logs, VariableUpdateLog.class).get(1);
+ List<ProcessLog> logs = loggingSession.findLogsByToken(processInstance.getRootToken().getId());
+ return LoggingInstance.getLogs(logs, VariableUpdateLog.class).get(1);
}
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ActionLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ActionLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ActionLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -59,11 +59,11 @@
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List actionLogs = loggingInstance.getLogs(ActionLog.class);
+ List<ActionLog> actionLogs = loggingInstance.getLogs(ActionLog.class);
assertEquals(1, actionLogs.size());
- ActionLog actionLog = (ActionLog) actionLogs.get(0);
+ ActionLog actionLog = actionLogs.get(0);
assertSame(token, actionLog.getToken());
assertSame(LoggedAction.class, actionLog.getAction().getActionDelegation().getInstance().getClass());
assertNull(actionLog.getException());
@@ -99,11 +99,11 @@
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List actionLogs = loggingInstance.getLogs(ActionLog.class);
+ List<ActionLog> actionLogs = loggingInstance.getLogs(ActionLog.class);
assertEquals(1, actionLogs.size());
- ActionLog actionLog = (ActionLog) actionLogs.get(0);
+ ActionLog actionLog = actionLogs.get(0);
assertSame(token, actionLog.getToken());
assertSame(LoggedExceptionAction.class, actionLog.getAction().getActionDelegation().getInstance().getClass());
assertNotNull(actionLog.getException());
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/NodeLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/NodeLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/NodeLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -50,9 +50,9 @@
processInstance.signal();
- List nodeLogs = loggingInstance.getLogs(NodeLog.class);
+ List<NodeLog> nodeLogs = loggingInstance.getLogs(NodeLog.class);
assertEquals(1, nodeLogs.size());
- NodeLog nodeLog = (NodeLog) nodeLogs.get(0);
+ NodeLog nodeLog = nodeLogs.get(0);
assertSame(processDefinition.getNode("s"), nodeLog.node);
assertNotNull(nodeLog.enter);
assertNotNull(nodeLog.leave);
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessInstanceLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessInstanceLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessInstanceLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -34,9 +34,9 @@
ProcessDefinition processDefinition = new ProcessDefinition();
ProcessInstance processInstance = new ProcessInstance(processDefinition);
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List processInstanceCreateLogs = loggingInstance.getLogs(ProcessInstanceCreateLog.class);
+ List<ProcessInstanceCreateLog> processInstanceCreateLogs = loggingInstance.getLogs(ProcessInstanceCreateLog.class);
assertEquals(1, processInstanceCreateLogs.size());
- ProcessInstanceCreateLog processInstanceCreateLog = (ProcessInstanceCreateLog) processInstanceCreateLogs.get(0);
+ ProcessInstanceCreateLog processInstanceCreateLog = processInstanceCreateLogs.get(0);
assertSame(processInstance.getRootToken(), processInstanceCreateLog.getToken());
}
@@ -53,9 +53,9 @@
ProcessInstance processInstance = new ProcessInstance(processDefinition);
processInstance.end();
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List processInstanceEndLogs = loggingInstance.getLogs(ProcessInstanceEndLog.class);
+ List<ProcessInstanceEndLog> processInstanceEndLogs = loggingInstance.getLogs(ProcessInstanceEndLog.class);
assertEquals(1, processInstanceEndLogs.size());
- ProcessInstanceEndLog processInstanceEndLog = (ProcessInstanceEndLog) processInstanceEndLogs.get(0);
+ ProcessInstanceEndLog processInstanceEndLog = processInstanceEndLogs.get(0);
assertSame(processInstance.getRootToken(), processInstanceEndLog.getToken());
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessLogsTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessLogsTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/ProcessLogsTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -32,47 +32,42 @@
public class ProcessLogsTest extends AbstractJbpmTestCase {
public void testProcessInstanceStartLog() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition />"
- );
-
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition />");
+
// start a process instance
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
-
+
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List processLogs = loggingInstance.getLogs(ProcessInstanceCreateLog.class);
-
+ List<ProcessInstanceCreateLog> processLogs = loggingInstance.getLogs(ProcessInstanceCreateLog.class);
+
assertEquals(1, processLogs.size());
- ProcessInstanceCreateLog processInstanceCreateLog = (ProcessInstanceCreateLog) processLogs.get(0);
+ ProcessInstanceCreateLog processInstanceCreateLog = processLogs.get(0);
assertSame(token, processInstanceCreateLog.getToken());
assertNotNull(processInstanceCreateLog.getDate());
}
public void testProcessInstanceEndLog() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <start-state>" +
- " <transition to='end' />" +
- " </start-state>" +
- " <end-state name='end' />" +
- "</process-definition>"
- );
-
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <start-state>"
+ + " <transition to='end' />"
+ + " </start-state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
+
// start a process instance
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
processInstance.signal();
-
+
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List processLogs = loggingInstance.getLogs(ProcessInstanceEndLog.class);
-
+ List<ProcessInstanceEndLog> processLogs = loggingInstance.getLogs(ProcessInstanceEndLog.class);
assertEquals(1, processLogs.size());
- ProcessInstanceEndLog processInstanceEndLog = (ProcessInstanceEndLog) processLogs.get(0);
+ ProcessInstanceEndLog processInstanceEndLog = processLogs.get(0);
assertSame(token, processInstanceEndLog.getToken());
assertNotNull(processInstanceEndLog.getDate());
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/SignalLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/SignalLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/SignalLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -32,38 +32,35 @@
public class SignalLogTest extends AbstractJbpmTestCase {
public void testSignalLog() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <start-state>" +
- " <transition to='s' />" +
- " </start-state>" +
- " <state name='s'>" +
- " <transition to='s' />" +
- " </state>" +
- "</process-definition>"
- );
-
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <start-state>"
+ + " <transition to='s' />"
+ + " </start-state>"
+ + " <state name='s'>"
+ + " <transition to='s' />"
+ + " </state>"
+ + "</process-definition>");
+
// start a process instance
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
processInstance.signal();
-
+
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List processLogs = loggingInstance.getLogs(SignalLog.class);
+ List<SignalLog> processLogs = loggingInstance.getLogs(SignalLog.class);
// check that there is exactly one signal log
assertEquals(1, processLogs.size());
- SignalLog signalLog = (SignalLog) processLogs.get(0);
+ SignalLog signalLog = processLogs.get(0);
assertSame(token, signalLog.getToken());
assertNotNull(signalLog.getDate());
-
+
// now we signal a second time
processInstance.signal();
// and check if there are exactly 2 signal logs
assertEquals(2, loggingInstance.getLogs(SignalLog.class).size());
}
-
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/TransitionLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/TransitionLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/graph/log/TransitionLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -32,40 +32,40 @@
public class TransitionLogTest extends AbstractJbpmTestCase {
public void testBasicTransitionLogs() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <start-state>" +
- " <transition to='state' />" +
- " </start-state>" +
- " <state name='state'>" +
- " <transition to='end' />" +
- " </state>" +
- " <end-state name='end' />" +
- "</process-definition>"
- );
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <start-state>"
+ + " <transition to='state' />"
+ + " </start-state>"
+ + " <state name='state'>"
+ + " <transition to='end' />"
+ + " </state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
// start a process instance
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
processInstance.signal();
-
+
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List transitionLogs = loggingInstance.getLogs(TransitionLog.class);
+ List<TransitionLog> transitionLogs = loggingInstance.getLogs(TransitionLog.class);
assertEquals(1, transitionLogs.size());
- TransitionLog transitionLog = (TransitionLog) transitionLogs.get(0);
+
+ TransitionLog transitionLog = transitionLogs.get(0);
assertSame(token, transitionLog.getToken());
assertNotNull(transitionLog.getDate());
assertSame(processDefinition.getStartState(), transitionLog.getSourceNode());
assertSame(processDefinition.getNode("state"), transitionLog.getDestinationNode());
- // signal the process to continue (which will move it to the end state)
+ // signal the process to continue (which will move it to the end state)
processInstance.signal();
-
+
// check the transition log (from the state to the end state)
transitionLogs = loggingInstance.getLogs(TransitionLog.class);
assertEquals(2, transitionLogs.size());
- transitionLog = (TransitionLog) transitionLogs.get(1);
+
+ transitionLog = transitionLogs.get(1);
assertSame(token, transitionLog.getToken());
assertNotNull(transitionLog.getDate());
assertSame(processDefinition.getNode("state"), transitionLog.getSourceNode());
@@ -73,30 +73,29 @@
}
public void testUseSuperStateTransitionLogs() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <start-state>" +
- " <transition to='superstate/state' />" +
- " </start-state>" +
- " <super-state name='superstate'>" +
- " <state name='state'/>" +
- " <transition to='end' />" +
- " </super-state>" +
- " <end-state name='end' />" +
- "</process-definition>"
- );
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <start-state>"
+ + " <transition to='superstate/state' />"
+ + " </start-state>"
+ + " <super-state name='superstate'>"
+ + " <state name='state'/>"
+ + " <transition to='end' />"
+ + " </super-state>"
+ + " <end-state name='end' />"
+ + "</process-definition>");
// start a process instance
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
processInstance.signal();
processInstance.signal();
-
+
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List transitionLogs = loggingInstance.getLogs(TransitionLog.class);
+ List<TransitionLog> transitionLogs = loggingInstance.getLogs(TransitionLog.class);
assertEquals(2, transitionLogs.size());
- TransitionLog transitionLog = (TransitionLog) transitionLogs.get(1);
+
+ TransitionLog transitionLog = transitionLogs.get(1);
assertSame(token, transitionLog.getToken());
assertNotNull(transitionLog.getDate());
assertSame(processDefinition.findNode("superstate/state"), transitionLog.getSourceNode());
@@ -104,27 +103,26 @@
}
public void testTransitionToSuperStateFirstChildLogs() {
- ProcessDefinition processDefinition = ProcessDefinition.parseXmlString(
- "<process-definition>" +
- " <start-state>" +
- " <transition to='superstate' />" +
- " </start-state>" +
- " <super-state name='superstate'>" +
- " <state name='state'/>" +
- " </super-state>" +
- "</process-definition>"
- );
+ ProcessDefinition processDefinition = ProcessDefinition.parseXmlString("<process-definition>"
+ + " <start-state>"
+ + " <transition to='superstate' />"
+ + " </start-state>"
+ + " <super-state name='superstate'>"
+ + " <state name='state'/>"
+ + " </super-state>"
+ + "</process-definition>");
// start a process instance
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
processInstance.signal();
-
+
// check the transition log (from the start state to the state)
LoggingInstance loggingInstance = processInstance.getLoggingInstance();
- List transitionLogs = loggingInstance.getLogs(TransitionLog.class);
+ List<TransitionLog> transitionLogs = loggingInstance.getLogs(TransitionLog.class);
assertEquals(1, transitionLogs.size());
- TransitionLog transitionLog = (TransitionLog) transitionLogs.get(0);
+
+ TransitionLog transitionLog = transitionLogs.get(0);
assertSame(token, transitionLog.getToken());
assertNotNull(transitionLog.getDate());
assertSame(processDefinition.getStartState(), transitionLog.getSourceNode());
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/exe/CompositeLogTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/exe/CompositeLogTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/exe/CompositeLogTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -30,72 +30,72 @@
import org.jbpm.logging.log.ProcessLog;
public class CompositeLogTest extends AbstractJbpmTestCase {
-
+
public void testCompositeLogs() {
ProcessDefinition processDefinition = new ProcessDefinition();
ProcessInstance pi = new ProcessInstance(processDefinition);
Token root = pi.getRootToken();
- LoggingInstance li = (LoggingInstance) pi.getInstance(LoggingInstance.class);
-
+ LoggingInstance li = pi.getInstance(LoggingInstance.class);
+
ProcessLog one = new MessageLog(null);
li.addLog(one);
-
- assertNull( one.getParent() );
- assertSame( one, li.getLogs().get(1) );
- assertEquals( 2, li.getLogs().size() );
- assertEquals( 0, li.getCompositeLogStack().size() );
+ assertNull(one.getParent());
+ assertSame(one, li.getLogs().get(1));
+ assertEquals(2, li.getLogs().size());
+ assertEquals(0, li.getCompositeLogStack().size());
+
CompositeLog two = new CompositeLog();
two.setToken(root);
li.startCompositeLog(two);
- assertNull( two.getParent() );
- assertSame( two, li.getLogs().get(2) );
- assertEquals( 3, li.getLogs().size() );
- assertEquals( 1, li.getCompositeLogStack().size() );
+ assertNull(two.getParent());
+ assertSame(two, li.getLogs().get(2));
+ assertEquals(3, li.getLogs().size());
+ assertEquals(1, li.getCompositeLogStack().size());
ProcessLog three = new MessageLog(null);
li.addLog(three);
- assertSame( two, three.getParent() );
- assertSame( three, li.getLogs().get(3) );
- assertEquals( 4, li.getLogs().size() );
- assertEquals( 1, li.getCompositeLogStack().size() );
+ assertSame(two, three.getParent());
+ assertSame(three, li.getLogs().get(3));
+ assertEquals(4, li.getLogs().size());
+ assertEquals(1, li.getCompositeLogStack().size());
CompositeLog four = new CompositeLog();
four.setToken(root);
li.startCompositeLog(four);
- assertSame( two, four.getParent() );
- assertSame( four, li.getLogs().get(4) );
- assertEquals( 5, li.getLogs().size() );
- assertEquals( 2, li.getCompositeLogStack().size() );
+ assertSame(two, four.getParent());
+ assertSame(four, li.getLogs().get(4));
+ assertEquals(5, li.getLogs().size());
+ assertEquals(2, li.getCompositeLogStack().size());
ProcessLog five = new MessageLog(null);
li.addLog(five);
- assertSame( four, five.getParent() );
- assertSame( two, five.getParent().getParent() );
- assertNull( five.getParent().getParent().getParent() );
- assertSame( five, li.getLogs().get(5) );
- assertEquals( 6, li.getLogs().size() );
- assertEquals( 2, li.getCompositeLogStack().size() );
+ assertSame(four, five.getParent());
+ assertSame(two, five.getParent().getParent());
+ assertNull(five.getParent().getParent().getParent());
+ assertSame(five, li.getLogs().get(5));
+ assertEquals(6, li.getLogs().size());
+ assertEquals(2, li.getCompositeLogStack().size());
li.endCompositeLog();
- assertEquals( 1, li.getCompositeLogStack().size() );
+ assertEquals(1, li.getCompositeLogStack().size());
ProcessLog six = new MessageLog(null);
li.addLog(six);
- assertSame( two, six.getParent() );
- assertNull( six.getParent().getParent() );
- assertSame( six, li.getLogs().get(6) );
- assertEquals( 7, li.getLogs().size() );
- assertEquals( 1, li.getCompositeLogStack().size() );
+ assertSame(two, six.getParent());
+ assertNull(six.getParent().getParent());
+ assertSame(six, li.getLogs().get(6));
+ assertEquals(7, li.getLogs().size());
+ assertEquals(1, li.getCompositeLogStack().size());
li.endCompositeLog();
-
- assertEquals( 0, li.getCompositeLogStack().size() );
+
+ assertEquals(0, li.getCompositeLogStack().size());
}
}
Modified: jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/log/ProcessLogDbTest.java
===================================================================
--- jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/log/ProcessLogDbTest.java 2009-01-28 03:17:25 UTC (rev 3724)
+++ jbpm3/trunk/modules/core/src/test/java/org/jbpm/logging/log/ProcessLogDbTest.java 2009-01-28 05:23:55 UTC (rev 3725)
@@ -22,38 +22,34 @@
package org.jbpm.logging.log;
import java.util.Date;
-import java.util.Iterator;
import org.jbpm.db.AbstractDbTestCase;
import org.jbpm.graph.exe.Token;
import org.jbpm.util.DateDbTestUtil;
-public class ProcessLogDbTest extends AbstractDbTestCase
-{
+public class ProcessLogDbTest extends AbstractDbTestCase {
- public void testMessageLogMessage()
- {
+ public void testMessageLogMessage() {
MessageLog messageLog = new MessageLog("piece of cake");
- messageLog = (MessageLog)saveAndReload(messageLog);
+ messageLog = (MessageLog) saveAndReload(messageLog);
assertEquals("piece of cake", messageLog.getMessage());
session.delete(messageLog);
}
- public void testProcessLogDate()
- {
+ public void testProcessLogDate() {
Date now = new Date();
ProcessLog processLog = new MessageLog();
processLog.setDate(now);
processLog = saveAndReload(processLog);
// assertEquals(now, processLog.getDate());
// assertEquals(now.getTime(), processLog.getDate().getTime());
- assertEquals(DateDbTestUtil.getInstance().convertDateToSeconds(now), DateDbTestUtil.getInstance().convertDateToSeconds(processLog.getDate()));
+ assertEquals(DateDbTestUtil.getInstance().convertDateToSeconds(now),
+ DateDbTestUtil.getInstance().convertDateToSeconds(processLog.getDate()));
session.delete(processLog);
}
- public void testProcessLogToken()
- {
+ public void testProcessLogToken() {
Token token = new Token();
session.save(token);
ProcessLog processLog = new MessageLog();
@@ -65,8 +61,7 @@
session.delete(token);
}
- public void testParentChildRelation()
- {
+ public void testParentChildRelation() {
CompositeLog compositeLog = new CompositeLog();
ProcessLog procLog = new MessageLog("one");
session.save(procLog);
@@ -78,16 +73,13 @@
session.save(procLog);
compositeLog.addChild(procLog);
- compositeLog = (CompositeLog)saveAndReload(compositeLog);
+ compositeLog = (CompositeLog) saveAndReload(compositeLog);
assertEquals(3, compositeLog.getChildren().size());
- Iterator iter = compositeLog.getChildren().iterator();
- while (iter.hasNext())
- {
- ProcessLog childLog = (ProcessLog)iter.next();
+ for (ProcessLog childLog : compositeLog.getChildren()) {
assertSame(compositeLog, childLog.getParent());
}
-
+
session.delete(compositeLog);
}
More information about the jbpm-commits
mailing list