testbasicloop.java

jbpm的demo,带有流程设计

/**
 * $Source: /home/ws/rz65/CVS-Repository/WorkflowProjects/JBPM-Demo/src/test/testjbpmdemo/testbasic/TestBasicLoop.java,v $
 * $Revision: 1.1 $
 * $Date: 2005/03/12 10:47:06 $
 * $Author: rz65 $
 *
 * Copyright (c) 2005 Universitaet Karlsruhe (TH) / Rechenzentrum (RZ-UNI-UKA)
 *
 * RZ-UNI-KA makes no representations or warranties about the suitability
 * of this software, either express or implied, including but not limited
 * to the implied warranties of merchantability, fitness for a particular
 * purpose, or non-infringement. RZ-UNI-KA shall not be liable for any
 * damages as a result of using, modifying or distributing this software
 * or its derivatives.
 */

package testjbpmdemo.testbasic;

import testjbpmdemo.testbasic.AbstractBasicTestCase;

import junit.framework.Test;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

import org.jbpm.context.def.ContextDefinition;

import org.jbpm.graph.def.Action;
import org.jbpm.graph.def.GraphElement;
import org.jbpm.graph.def.Node;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.def.Transition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;

import org.jbpm.jpdl.xml.JpdlXmlReader;
import org.jbpm.jpdl.xml.JpdlXmlWriter;

import org.jbpm.logging.def.LoggingDefinition;

import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * A test case for the process definition.
 * 
 * <p>
 * 
 * @version $Revision: 1.1 $
 * @author mailto:[e-mail]
 */

public class TestBasicLoop extends AbstractBasicTestCase {

	/**
	 * Builds a test case instance.
	 * 
	 * @param name
	 *            The name of the case.
	 */
	public TestBasicLoop(String name) {
		super(name);
	}

	/**
	 * The stand-alone run main method.
	 * 
	 * @param args
	 *            The run-time arguments (ignored)
	 */
	public static void main(String[] args) {
		TestRunner.run(suite());
	}

	/**
	 * Creates a test suite from this class.
	 * 
	 * @return The test suite that covers all test... methods
	 */
	public static Test suite() {
		return new TestSuite(TestBasicLoop.class);
	}

	protected void setUp() throws Exception {
		String mn = "setUp";
		String resourceName = getDefaultXMLResourcePath();
		debug(mn, "resource name: " + resourceName);
		setUpProcessDefinition = JpdlXmlReader.parseFromResource(resourceName);
		debug(mn, "process definition: " + setUpProcessDefinition);
		setUpProcessInstance = new ProcessInstance(setUpProcessDefinition);
		debug(mn, "process instance: " + setUpProcessInstance);
		setUpToken = setUpProcessInstance.getRootToken();
		debug(mn, "root token: " + setUpToken);
	}

	private ProcessDefinition setUpProcessDefinition;

	private ProcessInstance setUpProcessInstance;

	private Token setUpToken;

	/**
	 * Check the set-up
	 */
	public void testSetUp() {
		assertNotNull("process definition must not be null.",
				setUpProcessDefinition);
		assertNotNull("process instance must not be null.",
				setUpProcessInstance);
		assertNotNull("token must not be null.", setUpToken);
	}

	public void testMainScenario() {
		String mn = "testMainScenario";

		// first check if the main path of execution is in the
		// start state of the process definition
		assertEquals(setUpProcessDefinition.getStartState(), setUpToken
				.getNode());

		int count = 0;
		
		// now, send a signal to enter the loop
		dumpToken("before entering loop");
		setUpToken.signal("enter loop");
		dumpToken("after entering loop");

		// ...did we enter the loop ?
		assertEquals(setUpProcessDefinition.getNode("loop start"), setUpToken
				.getNode());

		// first, we travers the loop manually.
		setUpToken.signal("continue loop");
		dumpToken("after continue loop");

		// right ? 
		assertEquals(setUpProcessDefinition.getNode("loop end"), setUpToken
				.getNode());

		// now, since we were successful, loop for several times
		while (2>count++) {
            debug(mn,"**** IN LOOP *** count=" + count);
			setUpToken.signal("reenter loop");
	     	dumpToken("after reenter loop");
		    setUpToken.signal("continue loop");
	     	dumpToken("after continue loop");
		}
		
        debug(mn,"**** BAILING OUT ****");
		setUpToken.signal("bail out");
		
		// now execution is in 'close door' and it's waiting for the sensor
		assertEquals(setUpProcessDefinition.getNode("epilogue"), setUpToken
				.getNode());

		// now, we can signal to the process that we have received an answer
		setUpToken.signal("finished");
		dumpToken("after finished");

		// now, the process execution is done.
		assertTrue(setUpProcessInstance.hasEnded());
	}

	private void dumpToken(String msg) {
		String mn = "dumpToken " + msg;
		debug(mn, "id: " + setUpToken.getId());
		debug(mn, "name: " + setUpToken.getName());
		debug(mn, "full name: " + setUpToken.getFullName());
		debug(mn, "node: " + setUpToken.getNode());
		debug(mn, "node: " + setUpToken.getNode());
		debug(mn, "parent: " + setUpToken.getParent());
		debug(mn, "children: " + setUpToken.getChildren());
		//debug(mn, "has active children: " + setUpToken.hasActiveChildren());
		debug(mn, "has ended: " + setUpToken.hasEnded());
		debug(mn, "has parent: " + setUpToken.hasParent());
		debug(mn, "is parent reactivated: " + setUpToken.isParentReactivated());
		debug(mn, "is root: " + setUpToken.isRoot());
		debug(mn, "is terminated implicitly: "
				+ setUpToken.isTerminatedImplicitly());
		debug(mn, "is termination implicit: "
				+ setUpToken.isTerminationImplicit());
	}
	
	
	/**
	 * Test the XML writer result.
	 */
	public void testXmlWriterResults() {
		String mn="testXmlWriterResults";
		String s = JpdlXmlWriter.toString(setUpProcessDefinition);
		assertNotNull("writer result must not be null.",s);
		debug(mn,"writer result length: " + s.length());
		debug(mn,"result: " + s);
	}

}