Source code: domain/States.java

   /*
    * Danet GmbH
    * Beratung und Software-Entwicklung
    * Geschäftstelle AN
    *
    * $Id: States.java,v 1.22 2003/06/05 17:26:58 lipp Exp $
    *
    * $Log: States.java,v $
    * Revision 1.22  2003/06/05 17:26:58  lipp
   * Extended error message.
   *
   * Revision 1.21  2003/04/26 16:12:35  lipp
   * Moved some classes to reduce package dependencies.
   *
   * Revision 1.20  2002/11/11 12:20:44  lipp
   * Some fixes.
   *
   * Revision 1.19  2002/10/21 19:08:05  lipp
   * Continuing implementation of new state handling.
   *
   * Revision 1.18  2002/10/21 16:59:55  lipp
   * More fixes.
   *
   * Revision 1.17  2002/10/21 16:24:24  lipp
   * Added state compatibility test.
   *
   * Revision 1.16  2002/10/21 13:48:03  lipp
   * Continuing implementation of new state handling.
   *
   * Revision 1.15  2002/10/21 11:54:23  lipp
   * Better suspend state handling.
   *
   * Revision 1.14  2002/10/09 14:27:33  lipp
   * Intermediate, compilable state.
   *
   * Revision 1.13  2002/08/30 13:37:05  lipp
   * Using Workflow engine facade now.
   *
   * Revision 1.12  2002/08/22 15:19:34  lipp
   * Redesign of EJB persistence.
   *
   * Revision 1.11  2002/08/21 22:06:48  lipp
   * Finished transition to ProcessMgrStub.
   *
   * Revision 1.10  2002/08/02 09:28:53  huaiyang
   * Use JDOM.
   *
   * Revision 1.9  2002/02/04 22:43:12  lipp
   * Adapted tests to changed.
   *
   * Revision 1.8  2002/01/23 15:42:04  lipp
   * Adapted to interface changes.
   *
   * Revision 1.7  2001/12/13 21:00:05  lipp
   * Simplified temporary implementation of a requester.
   *
   * Revision 1.6  2001/10/08 10:58:24  lipp
   * Adapted to interface/implementation separation in domain.
   *
   * Revision 1.5  2001/09/26 13:52:46  montag
   * *** empty log message ***
   *
   * Revision 1.4  2001/09/25 12:12:03  montag
   * unittests corrected
   *
   * Revision 1.3  2001/09/24 13:54:15  montag
   * WfProcessPK, WfActivityPK and ContributorPK removed.
   *
   * Revision 1.2  2001/09/07 11:47:49  montag
   * new substates for open.not_running.suspended
   *
   * Revision 1.1  2001/08/29 10:59:11  lipp
   * Tests split in groups.
   *
   */
  package domain;
  
  import de.danet.an.workflow.omgcore.NotRunningException;
  import de.danet.an.workflow.omgcore.TransitionNotAllowedException;
  import de.danet.an.workflow.omgcore.WfExecutionObject;
  
  import de.danet.an.workflow.api.Activity.StartFinishMode;
  
  import de.danet.an.workflow.domain.AbstractExecutionObject;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  
  /**
   * Zusammenstellung aller TimerObjectTests.
   * @author <a href="mailto:lipp@danet.de"></a>
   * @version 1.0
   */
  public class States extends TestCase {
  
      /**
       * Konstruktor zum Erzeugen eines TestCase
       * @param name a <code>String</code> value
      */
     public States(String name) {
   super (name);
     }
 
     /**
      * Stellt diese TestSuite zusammen.
      * @return a <code>Test</code> value
      */
     public static Test suite() {
         TestSuite suite = new TestSuite();
      suite.addTest(new States("availableStates"));
        suite.addTest(new States("executionState"));
        suite.addTest(new States("availableModes"));
         return suite;
     }
   
     /**
      * Check if state machine for 1for avaiable states of the 1. iteration.
      * @exception Exception if an error occurs
      */
     public void availableStates() throws Exception {
   WfExecutionObject.State[] states = new WfExecutionObject.State[11];
    states[0] = WfExecutionObject.State.fromString("open");
   assertTrue (states[0] != null);
    states[1] = WfExecutionObject.State.fromString("closed");
   assertTrue (states[1] != null);
    states[2] = WfExecutionObject.State.fromString("open.running");
   assertTrue (states[2] != null);
    states[3] = WfExecutionObject.State.fromString("open.not_running");
   assertTrue (states[3] != null);
    states[4] = WfExecutionObject.State.fromString
       ("open.not_running.not_started");
   assertTrue (states[4] != null);
    states[5] = WfExecutionObject.State.fromString
       ("open.not_running.suspended");
   assertTrue (states[5] != null);
    states[6] = WfExecutionObject.State.fromString("closed.completed");
   assertTrue (states[6] != null);
    states[7] = WfExecutionObject.State.fromString("closed.aborted");
   assertTrue (states[7] != null);
    states[8] = WfExecutionObject.State.fromString("closed.terminated");
   assertTrue (states[8] != null);
   WfExecutionObject.State s 
       = AbstractExecutionObject.RunningState.RUNNING;
   s = AbstractExecutionObject.SuspendedState.SUSPENDED;
    states[9] = WfExecutionObject.State
       .fromString("open.not_running.suspended.aborting");
   assertTrue (states[9] != null);
    states[10] = WfExecutionObject.State
       .fromString("open.running.terminating");
   assertTrue (states[10] != null);
 
   for (int i=0; i<11;i++) {
       for (int j=0; j<11;j++) {
     if (states[i].toString().equals(states[j].toString())
         || (states[i].toString()
       .startsWith(states[j].toString() + "."))) {
         assertTrue (states[i] + " should be same or have substate "
         + states[j], 
         states[i].isSameOrSubState(states[j]));
     } else {
         assertTrue 
       (states[i] + " should not be same or have substate " 
        + states[j], 
        !states[i].isSameOrSubState(states[j]));
     }
       }
   }
     }
 
     /**
      * Check if state machine for 1. iteration works.
      * @exception Exception if an error occurs
      */
     public void executionState() throws Exception {
   VolatileProcess aeo = new VolatileProcess();
   VolatileActivity act = new VolatileActivity (aeo);
   aeo.addActivity (act);
   act.setStartMode (StartFinishMode.MANUAL);
   assertTrue(aeo.state().equals("open.not_running.not_started"));
   assertTrue(aeo.workflowState().equals(WfExecutionObject.State.OPEN));
   assertTrue(aeo.whileOpen()
        .equals(WfExecutionObject.OpenState.NOT_RUNNING));
   assertTrue(aeo.whyNotRunning()
        .equals(WfExecutionObject.NotRunningState.NOT_STARTED));
   boolean exceptionCaught = false;
   try {
       aeo.howClosed();
   } catch (IllegalStateException is) {
       exceptionCaught = true;
   }
   assertTrue (exceptionCaught);    
   // change to illegal state
   exceptionCaught = false;
   try {
       aeo.changeState(WfExecutionObject
           .ClosedState.COMPLETED.toString());
   } catch (TransitionNotAllowedException ie) {
       exceptionCaught = true;
   }
   assertTrue (exceptionCaught);
   // change to illegal state
   exceptionCaught = false;
   try {
       aeo.suspend();
   } catch (NotRunningException ce) {
       exceptionCaught = true;
   }
   assertTrue (exceptionCaught);
 
   // legal change
   aeo.changeState(WfExecutionObject.OpenState.RUNNING.toString());
   // change to illegal transition
   exceptionCaught = false;
   try {
       aeo.changeState(WfExecutionObject
           .NotRunningState.NOT_STARTED.toString());
   } catch (TransitionNotAllowedException te) {
       exceptionCaught = true;
   }
   assertTrue (exceptionCaught);
   // finally abort
   aeo.suspend();
   aeo.abort();
   assertTrue(aeo.state().equals("closed.aborted"));
   assertTrue(aeo.workflowState().equals(WfExecutionObject.State.CLOSED));
   exceptionCaught = false;
   try {
       aeo.whileOpen();
   } catch (IllegalStateException is2) {
       exceptionCaught = true;
   }
   assertTrue (exceptionCaught);    
   exceptionCaught = false;
   try {
       aeo.whyNotRunning();
   } catch (IllegalStateException is3) {
       exceptionCaught = true;
   }
   assertTrue (exceptionCaught);    
   assertTrue (aeo.howClosed()
         .equals(WfExecutionObject.ClosedState.ABORTED));
     }
 
     /**
      * Check if state machine for 1for avaiable states of the 1. iteration.
      * @exception Exception if an error occurs
      */
     public void availableModes() throws Exception {
   StartFinishMode[] modes = new StartFinishMode[3];
    modes[0] = StartFinishMode.fromString("Manual");
   assertTrue (modes[0] == StartFinishMode.MANUAL);
    modes[1] = StartFinishMode.fromString("Automatic");
   assertTrue (modes[1] == StartFinishMode.AUTOMATIC);
     }
 
 }