Author: alex.guizar(a)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); }