[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