[jboss-svn-commits] JBL Code SVN: r32947 - in labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src: main/java/org/drools/task/service/hornetq and 7 other directories.

Tue May 18 23:26:48 EDT 2010

Author: lucazamador
Date: 2010-05-18 23:26:46 -0400 (Tue, 18 May 2010)
New Revision: 32947

Added:
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/hornetq/
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/hornetq/WSHumanTaskHandlerHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/mina/
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/mina/WSHumanTaskHandlerMinaTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/IcalHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskLifeCycleHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceDeadlinesHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEscalationHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEventMessagingHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceLifeCycleHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/IcalMinaTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskLifeCycleMinaTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceDeadlinesMinaQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEscalationMinaTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEventMessagingMinaTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceLifeCycleMinaTest.java
Removed:
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleTest.java
Modified:
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/BaseHornetQTaskServer.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskClientConnector.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskServer.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/QueryTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceCommentsAndAttachmentsBaseTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceCommentsAndAttachmentsHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceHornetQTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceCommentsAndAttachmentsMinaTest.java
   labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceMinaTest.java
Log:
all tests migrated to hornetq. added standalone hornetq support

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java
===================================================================

--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/process/workitem/wsht/WSHumanTaskHandler.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -53,6 +53,10 @@
 		this.port = port;
 	}
 	
+	public void setClient(TaskClient client) {
+		this.client = client;
+	}
+	
 	public void connect() {
 		if (client == null) {
 			client = new TaskClient(new MinaTaskClientConnector("org.drools.process.workitem.wsht.WSHumanTaskHandler",
@@ -62,15 +66,15 @@
 			if (!connected) {
 				throw new IllegalArgumentException("Could not connect task client");
 			}
-			TaskEventKey key = new TaskEventKey(TaskCompletedEvent.class, -1);           
-            TaskCompletedHandler eventResponseHandler = new TaskCompletedHandler(manager, client);
-            client.registerForEvent(key, false, eventResponseHandler);
-            key = new TaskEventKey(TaskFailedEvent.class, -1);           
-            client.registerForEvent(key, false, eventResponseHandler);
-            key = new TaskEventKey(TaskSkippedEvent.class, -1);           
-            client.registerForEvent(key, false, eventResponseHandler);
-            System.out.println("Registered human task listener");
 		}
+		TaskEventKey key = new TaskEventKey(TaskCompletedEvent.class, -1);           
+		TaskCompletedHandler eventResponseHandler = new TaskCompletedHandler(manager, client);
+		client.registerForEvent(key, false, eventResponseHandler);
+		key = new TaskEventKey(TaskFailedEvent.class, -1);           
+		client.registerForEvent(key, false, eventResponseHandler);
+		key = new TaskEventKey(TaskSkippedEvent.class, -1);           
+		client.registerForEvent(key, false, eventResponseHandler);
+		System.out.println("Registered human task listener");
 	}
 	
 	public void setManager(WorkItemManager manager) {

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/BaseHornetQTaskServer.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/BaseHornetQTaskServer.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/BaseHornetQTaskServer.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -25,32 +25,37 @@
 
 public class BaseHornetQTaskServer extends TaskServer {
 
-	public static final String SERVER_TASK_COMMANDS_QUEUE = "taskCommandsQueue";
+	public static final String SERVER_TASK_COMMANDS_QUEUE = "tasksQueue";
 
 	private HornetQServer server;
 	private HornetQTaskServerHandler handler;
 	private Configuration configuration;
+	private boolean standalone;
 
 	private final int port;
 	volatile boolean  running;
+	private boolean internalServerRunning;
 
 	private ClientSession session;
 	private ClientConsumer consumer;
 
-	public BaseHornetQTaskServer(HornetQTaskServerHandler handler, int port) {
+	public BaseHornetQTaskServer(HornetQTaskServerHandler handler, int port, boolean standalone) {
 		this.handler = handler;
 		this.port = port;
+		this.standalone = standalone;
 	}
 
-	public BaseHornetQTaskServer(HornetQTaskServerHandler handler, int port, Configuration configuration) {
-		this(handler, port);
+	public BaseHornetQTaskServer(HornetQTaskServerHandler handler, int port, Configuration configuration, boolean standalone) {
+		this.handler = handler;
+		this.port = port;
 		this.configuration = configuration;
+		this.standalone = standalone;
 	}
 
 	public void run() {
 		try {
 			start();
-			while (running) {
+			while (internalServerRunning) {
 				System.out.println("server: waiting messages...");
 				ClientMessage msgReceived = consumer.receive();
 				if (msgReceived!=null) {
@@ -63,7 +68,14 @@
 		}
 		catch (HornetQException e) {
 			// TODO: handle exception, connection closed is a very common exception
-			e.printStackTrace();
+			switch (e.getCode()) {
+			case HornetQException.OBJECT_CLOSED:
+				// log: connection is closed/lost 
+				break;
+			default:
+				e.printStackTrace();
+				break;
+			}
 		}
 		catch (Exception e) {
 			throw new RuntimeException("Server Exception with class " + getClass() + " using port " + port, e);
@@ -80,37 +92,52 @@
 	}
 
 	public void start() throws Exception {
-		if (configuration==null) {
-			configuration = new ConfigurationImpl();
-			configuration.setPersistenceEnabled(false);
-			configuration.setSecurityEnabled(false);
-		}
 
 		Map<String, Object> connectionParams = new HashMap<String, Object>();
 		connectionParams.put(TransportConstants.PORT_PROP_NAME, port);
 
-		TransportConfiguration transpConf = new TransportConfiguration(NettyAcceptorFactory.class.getName(), connectionParams);
+		if (!standalone) {
+			if (configuration==null) {
+				configuration = new ConfigurationImpl();
+				configuration.setPersistenceEnabled(false);
+				configuration.setSecurityEnabled(false);
+			}
 
-		HashSet<TransportConfiguration> setTransp = new HashSet<TransportConfiguration>();
-		setTransp.add(transpConf);
+			TransportConfiguration transpConf = new TransportConfiguration(NettyAcceptorFactory.class.getName(), connectionParams);
 
-		configuration.setAcceptorConfigurations(setTransp);
+			HashSet<TransportConfiguration> setTransp = new HashSet<TransportConfiguration>();
+			setTransp.add(transpConf);
 
-		server = HornetQServers.newHornetQServer(configuration);
-		server.start();
+			configuration.setAcceptorConfigurations(setTransp);
 
+			server = HornetQServers.newHornetQServer(configuration);
+			server.start();
+			running = true;
+		}
+
 		TransportConfiguration transportConfiguration = new TransportConfiguration(NettyConnectorFactory.class.getCanonicalName(), connectionParams);
 		ClientSessionFactory factory = HornetQClient.createClientSessionFactory(transportConfiguration);
 		session = factory.createSession();
-		session.createQueue(SERVER_TASK_COMMANDS_QUEUE, SERVER_TASK_COMMANDS_QUEUE, true);
+		try {
+			session.createQueue(SERVER_TASK_COMMANDS_QUEUE, SERVER_TASK_COMMANDS_QUEUE, true);
+		} catch (HornetQException e) {
+			if (e.getCode()!=HornetQException.QUEUE_EXISTS) {
+				// log: queue already exists!
+				throw e;
+			}
+		}
 		consumer = session.createConsumer(SERVER_TASK_COMMANDS_QUEUE);
 		session.start();
-		System.out.println("QUEUE '" + SERVER_TASK_COMMANDS_QUEUE + "' CREATED::");
-		running = true;
+		internalServerRunning = true;
 	}
 
 	public void stop() throws Exception {
-		server.stop();
-		running = false;
+		if (internalServerRunning) {
+			session.stop();
+		}
+		if (running) {
+			server.stop();
+			running = false;
+		}
 	}
 }
\ No newline at end of file

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskClientConnector.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskClientConnector.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskClientConnector.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -85,8 +85,16 @@
 							}
 						}
 					} catch (HornetQException e) {
-						if (e.getCode()!=HornetQException.OBJECT_CLOSED) {
+						switch (e.getCode()) {
+						case HornetQException.OBJECT_CLOSED:
+							// log: connection is closed/lost
+							break;
+						case HornetQException.QUEUE_EXISTS:
+							// log: queue already exists
+							break;
+						default:
 							e.printStackTrace();
+							break;
 						}
 					} catch (Exception e) {
 						// TODO Auto-generated catch block
@@ -96,6 +104,8 @@
 				}
 			});
 			responsesThread.start();
+			
+			session.start();
 
 			return true;
 		} catch (Exception e) {

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskServer.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskServer.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/main/java/org/drools/task/service/hornetq/HornetQTaskServer.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -7,10 +7,18 @@
 public class HornetQTaskServer extends BaseHornetQTaskServer implements Runnable {
 
 	public HornetQTaskServer(TaskService service, int port) {
-		super(new HornetQTaskServerHandler(service, SystemEventListenerFactory.getSystemEventListener()), port);
+		super(new HornetQTaskServerHandler(service, SystemEventListenerFactory.getSystemEventListener()), port, false);
 	}
-	
+
+	public HornetQTaskServer(TaskService service, int port, boolean standalone) {
+		super(new HornetQTaskServerHandler(service, SystemEventListenerFactory.getSystemEventListener()), port, standalone);
+	}
+
 	public HornetQTaskServer(TaskService service, int port, Configuration configuration) {
-		super(new HornetQTaskServerHandler(service, SystemEventListenerFactory.getSystemEventListener()), port, configuration);
+		super(new HornetQTaskServerHandler(service, SystemEventListenerFactory.getSystemEventListener()), port, configuration, false);
 	}
+
+	public HornetQTaskServer(TaskService service, int port, Configuration configuration, boolean standalone) {
+		super(new HornetQTaskServerHandler(service, SystemEventListenerFactory.getSystemEventListener()), port, configuration, standalone);
+	}
 }
\ No newline at end of file

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,733 @@
+package org.drools.process.workitem.wsht;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.drools.process.instance.impl.WorkItemImpl;
+import org.drools.runtime.process.WorkItemHandler;
+import org.drools.runtime.process.WorkItemManager;
+import org.drools.task.AccessType;
+import org.drools.task.BaseTest;
+import org.drools.task.Status;
+import org.drools.task.Task;
+import org.drools.task.query.TaskSummary;
+import org.drools.task.service.ContentData;
+import org.drools.task.service.PermissionDeniedException;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskSummaryResponseHandler;
+
+public abstract class WSHumanTaskHandlerBaseTest extends BaseTest {
+
+	private static final int DEFAULT_WAIT_TIME = 5000;
+	private static final int MANAGER_COMPLETION_WAIT_TIME = DEFAULT_WAIT_TIME;
+	private static final int MANAGER_ABORT_WAIT_TIME = DEFAULT_WAIT_TIME;
+
+	private TaskClient client;
+	private WSHumanTaskHandler handler;
+
+	public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+
+	public void testTask() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary task = tasks.get(0);
+		assertEquals("TaskName", task.getName());
+		assertEquals(10, task.getPriority());
+		assertEquals("Comment", task.getDescription());
+		assertEquals(Status.Reserved, task.getStatus());
+		assertEquals("Darth Vader", task.getActualOwner().getId());
+
+		System.out.println("Starting task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started task " + task.getId());
+
+		System.out.println("Completing task " + task.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().complete(task.getId(), "Darth Vader", null, operationResponseHandler);
+		operationResponseHandler.waitTillDone(15000);
+		System.out.println("Completed task " + task.getId());
+		
+		Thread.sleep(DEFAULT_WAIT_TIME);
+
+		assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+	}
+
+	public void testTaskMultipleActors() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader, Dalai Lama");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary task = tasks.get(0);
+		assertEquals("TaskName", task.getName());
+		assertEquals(10, task.getPriority());
+		assertEquals("Comment", task.getDescription());
+		assertEquals(Status.Ready, task.getStatus());
+
+		System.out.println("Claiming task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().claim(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Claimed task " + task.getId());
+
+		System.out.println("Starting task " + task.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started task " + task.getId());
+
+		System.out.println("Completing task " + task.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().complete(task.getId(), "Darth Vader", null, operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Completed task " + task.getId());
+
+		assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+	}
+
+	public void testTaskGroupActors() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("GroupId", "Crusaders");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		List<String> groupIds = new ArrayList<String>();
+		groupIds.add("Crusaders");
+		getClient().getTasksAssignedAsPotentialOwner(null, groupIds, "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary taskSummary = tasks.get(0);
+		assertEquals("TaskName", taskSummary.getName());
+		assertEquals(10, taskSummary.getPriority());
+		assertEquals("Comment", taskSummary.getDescription());
+		assertEquals(Status.Ready, taskSummary.getStatus());
+
+		System.out.println("Claiming task " + taskSummary.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().claim(taskSummary.getId(), "Darth Vader", operationResponseHandler);
+		PermissionDeniedException denied = null;
+		try {
+			operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		} catch (PermissionDeniedException e) {
+			denied = e;
+		}
+
+		assertNotNull("Should get permissed denied exception", denied);
+		System.out.println("Claimed task " + taskSummary.getId());
+
+		//Check if the parent task is InProgress
+		BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(taskSummary.getId(), getTaskResponseHandler);
+		Task task = getTaskResponseHandler.getTask();
+		assertEquals(Status.Ready, task.getTaskData().getStatus());
+	}
+
+	public void testTaskSingleAndGroupActors() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task One");
+		workItem.setParameter("TaskName", "TaskNameOne");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("GroupId", "Crusaders");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		workItem = new WorkItemImpl();
+		workItem.setName("Human Task Two");
+		workItem.setParameter("TaskName", "TaskNameTwo");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		List<String> groupIds = new ArrayList<String>();
+		groupIds.add("Crusaders");
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", groupIds, "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(2, tasks.size());
+	}
+
+	public void testTaskFail() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary task = tasks.get(0);
+		assertEquals("TaskName", task.getName());
+		assertEquals(10, task.getPriority());
+		assertEquals("Comment", task.getDescription());
+		assertEquals(Status.Reserved, task.getStatus());
+		assertEquals("Darth Vader", task.getActualOwner().getId());
+
+		System.out.println("Starting task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started task " + task.getId());
+
+		System.out.println("Failing task " + task.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().fail(task.getId(), "Darth Vader", null, operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Failed task " + task.getId());
+
+		assertTrue(manager.waitTillAborted(MANAGER_ABORT_WAIT_TIME));
+	}
+
+	public void testTaskSkip() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary task = tasks.get(0);
+		assertEquals("TaskName", task.getName());
+		assertEquals(10, task.getPriority());
+		assertEquals("Comment", task.getDescription());
+		assertEquals(Status.Reserved, task.getStatus());
+		assertEquals("Darth Vader", task.getActualOwner().getId());
+
+		System.out.println("Skipping task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().skip(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Skipped task " + task.getId());
+
+		assertTrue(manager.waitTillAborted(MANAGER_ABORT_WAIT_TIME));
+	}
+
+	public void testTaskAbortSkippable() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		getHandler().abortWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(0, tasks.size());
+	}
+
+	public void testTaskAbortNotSkippable() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		workItem.setParameter("Skippable", "false");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+
+		getHandler().abortWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+	}
+
+	public void testTaskData() throws Exception {
+		TestWorkItemManager manager = new TestWorkItemManager();
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskName");
+		workItem.setParameter("Comment", "Comment");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		workItem.setParameter("Content", "This is the content");
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary taskSummary = tasks.get(0);
+		assertEquals("TaskName", taskSummary.getName());
+		assertEquals(10, taskSummary.getPriority());
+		assertEquals("Comment", taskSummary.getDescription());
+		assertEquals(Status.Reserved, taskSummary.getStatus());
+		assertEquals("Darth Vader", taskSummary.getActualOwner().getId());
+
+		BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(taskSummary.getId(), getTaskResponseHandler);
+		Task task = getTaskResponseHandler.getTask();
+		assertEquals(AccessType.Inline, task.getTaskData().getDocumentAccessType());
+		long contentId = task.getTaskData().getDocumentContentId();
+		assertTrue(contentId != -1);
+		BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
+		getClient().getContent(contentId, getContentResponseHandler);
+		ByteArrayInputStream bis = new ByteArrayInputStream(getContentResponseHandler.getContent().getContent());
+		ObjectInputStream in = new ObjectInputStream(bis);
+		Object data = in.readObject();
+		in.close();
+		assertEquals("This is the content", data);
+
+		System.out.println("Starting task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started task " + task.getId());
+
+		System.out.println("Completing task " + task.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		ContentData result = new ContentData();
+		result.setAccessType(AccessType.Inline);
+		result.setType("java.lang.String");
+		ByteArrayOutputStream bos = new ByteArrayOutputStream();
+		ObjectOutputStream out = new ObjectOutputStream(bos);
+		out.writeObject("This is the result");
+		out.close();
+		result.setContent(bos.toByteArray());
+		getClient().complete(task.getId(), "Darth Vader", result, operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Completed task " + task.getId());
+
+		assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+		Map<String, Object> results = manager.getResults();
+		assertNotNull(results);
+		assertEquals("Darth Vader", results.get("ActorId"));
+		assertEquals("This is the result", results.get("Result"));
+	}
+
+	public void TODOtestOnAllSubTasksEndParentEndStrategy() throws Exception {
+
+		TestWorkItemManager manager = new TestWorkItemManager();
+		//Create the parent task
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskNameParent");
+		workItem.setParameter("Comment", "CommentParent");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		//Set the subtask policy
+		workItem.setParameter("SubTaskStrategies", "OnAllSubTasksEndParentEnd");
+		getHandler().executeWorkItem(workItem, manager);
+
+
+		Thread.sleep(500);
+
+		//Test if the task is succesfully created
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary task = tasks.get(0);
+		assertEquals("TaskNameParent", task.getName());
+		assertEquals(10, task.getPriority());
+		assertEquals("CommentParent", task.getDescription());
+		assertEquals(Status.Reserved, task.getStatus());
+		assertEquals("Darth Vader", task.getActualOwner().getId());
+
+		//Create the child task
+		workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskNameChild1");
+		workItem.setParameter("Comment", "CommentChild1");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		workItem.setParameter("ParentId", task.getId());
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		//Create the child task2
+		workItem = new WorkItemImpl();
+		workItem.setName("Human Task2");
+		workItem.setParameter("TaskName", "TaskNameChild2");
+		workItem.setParameter("Comment", "CommentChild2");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		workItem.setParameter("ParentId", task.getId());
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		//Start the parent task
+		System.out.println("Starting task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started task " + task.getId());
+
+		//Check if the parent task is InProgress
+		BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(task.getId(), getTaskResponseHandler);
+		Task parentTask = getTaskResponseHandler.getTask();
+		assertEquals(Status.InProgress, parentTask.getTaskData().getStatus());
+		assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
+
+		//Get all the subtask created for the parent task based on the potential owner
+		responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getSubTasksAssignedAsPotentialOwner(parentTask.getId(), "Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> subTasks = responseHandler.getResults();
+		assertEquals(2, subTasks.size());
+		TaskSummary subTaskSummary1 = subTasks.get(0);
+		TaskSummary subTaskSummary2 = subTasks.get(1);
+		assertNotNull(subTaskSummary1);
+		assertNotNull(subTaskSummary2);
+
+		//Starting the sub task 1
+		System.out.println("Starting sub task " + subTaskSummary1.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(subTaskSummary1.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started sub task " + subTaskSummary1.getId());
+
+		//Starting the sub task 2
+		System.out.println("Starting sub task " + subTaskSummary2.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(subTaskSummary2.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started sub task " + subTaskSummary2.getId());
+
+		//Check if the child task 1 is InProgress
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTaskSummary1.getId(), getTaskResponseHandler);
+		Task subTask1 = getTaskResponseHandler.getTask();
+		assertEquals(Status.InProgress, subTask1.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+		//Check if the child task 2 is InProgress
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTaskSummary2.getId(), getTaskResponseHandler);
+		Task subTask2 = getTaskResponseHandler.getTask();
+		assertEquals(Status.InProgress, subTask2.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+		// Complete the child task 1
+		System.out.println("Completing sub task " + subTask1.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().complete(subTask1.getId(), "Darth Vader", null, operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Completed sub task " + subTask1.getId());
+
+		// Complete the child task 2
+		System.out.println("Completing sub task " + subTask2.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().complete(subTask2.getId(), "Darth Vader", null, operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Completed sub task " + subTask2.getId());
+
+		//Check if the child task 1 is Completed
+
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTask1.getId(), getTaskResponseHandler);
+		subTask1 = getTaskResponseHandler.getTask();
+		assertEquals(Status.Completed, subTask1.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+		//Check if the child task 2 is Completed
+
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTask2.getId(), getTaskResponseHandler);
+		subTask2 = getTaskResponseHandler.getTask();
+		assertEquals(Status.Completed, subTask2.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+		// Check is the parent task is Complete
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(parentTask.getId(), getTaskResponseHandler);
+		parentTask = getTaskResponseHandler.getTask();
+		assertEquals(Status.Completed, parentTask.getTaskData().getStatus());
+		assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
+
+		assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+	}
+
+	public void TODOtestOnParentAbortAllSubTasksEndStrategy() throws Exception {
+
+		TestWorkItemManager manager = new TestWorkItemManager();
+		//Create the parent task
+		WorkItemImpl workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskNameParent");
+		workItem.setParameter("Comment", "CommentParent");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		//Set the subtask policy
+		workItem.setParameter("SubTaskStrategies", "OnParentAbortAllSubTasksEnd");
+		getHandler().executeWorkItem(workItem, manager);
+
+
+		Thread.sleep(500);
+
+		//Test if the task is succesfully created
+		BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> tasks = responseHandler.getResults();
+		assertEquals(1, tasks.size());
+		TaskSummary task = tasks.get(0);
+		assertEquals("TaskNameParent", task.getName());
+		assertEquals(10, task.getPriority());
+		assertEquals("CommentParent", task.getDescription());
+		assertEquals(Status.Reserved, task.getStatus());
+		assertEquals("Darth Vader", task.getActualOwner().getId());
+
+		//Create the child task
+		workItem = new WorkItemImpl();
+		workItem.setName("Human Task");
+		workItem.setParameter("TaskName", "TaskNameChild1");
+		workItem.setParameter("Comment", "CommentChild1");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		workItem.setParameter("ParentId", task.getId());
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		//Create the child task2
+		workItem = new WorkItemImpl();
+		workItem.setName("Human Task2");
+		workItem.setParameter("TaskName", "TaskNameChild2");
+		workItem.setParameter("Comment", "CommentChild2");
+		workItem.setParameter("Priority", "10");
+		workItem.setParameter("ActorId", "Darth Vader");
+		workItem.setParameter("ParentId", task.getId());
+		getHandler().executeWorkItem(workItem, manager);
+
+		Thread.sleep(500);
+
+		//Start the parent task
+		System.out.println("Starting task " + task.getId());
+		BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(task.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started task " + task.getId());
+
+		//Check if the parent task is InProgress
+		BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(task.getId(), getTaskResponseHandler);
+		Task parentTask = getTaskResponseHandler.getTask();
+		assertEquals(Status.InProgress, parentTask.getTaskData().getStatus());
+		assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
+
+		//Get all the subtask created for the parent task based on the potential owner
+		responseHandler = new BlockingTaskSummaryResponseHandler();
+		getClient().getSubTasksAssignedAsPotentialOwner(parentTask.getId(), "Darth Vader", "en-UK", responseHandler);
+		List<TaskSummary> subTasks = responseHandler.getResults();
+		assertEquals(2, subTasks.size());
+		TaskSummary subTaskSummary1 = subTasks.get(0);
+		TaskSummary subTaskSummary2 = subTasks.get(1);
+		assertNotNull(subTaskSummary1);
+		assertNotNull(subTaskSummary2);
+
+		//Starting the sub task 1
+		System.out.println("Starting sub task " + subTaskSummary1.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(subTaskSummary1.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started sub task " + subTaskSummary1.getId());
+
+		//Starting the sub task 2
+		System.out.println("Starting sub task " + subTaskSummary2.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().start(subTaskSummary2.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Started sub task " + subTaskSummary2.getId());
+
+		//Check if the child task 1 is InProgress
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTaskSummary1.getId(), getTaskResponseHandler);
+		Task subTask1 = getTaskResponseHandler.getTask();
+		assertEquals(Status.InProgress, subTask1.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+		//Check if the child task 2 is InProgress
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTaskSummary2.getId(), getTaskResponseHandler);
+		Task subTask2 = getTaskResponseHandler.getTask();
+		assertEquals(Status.InProgress, subTask2.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+		// Complete the parent task
+		System.out.println("Completing parent task " + parentTask.getId());
+		operationResponseHandler = new BlockingTaskOperationResponseHandler();
+		getClient().skip(parentTask.getId(), "Darth Vader", operationResponseHandler);
+		operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+		System.out.println("Completed parent task " + parentTask.getId());
+
+		//Check if the child task 1 is Completed
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTaskSummary1.getId(), getTaskResponseHandler);
+		subTask1 = getTaskResponseHandler.getTask();
+		assertEquals(Status.Completed, subTask1.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
+
+		//Check if the child task 2 is Completed
+		getTaskResponseHandler = new BlockingGetTaskResponseHandler();
+		getClient().getTask(subTaskSummary2.getId(), getTaskResponseHandler);
+		subTask2 = getTaskResponseHandler.getTask();
+		assertEquals(Status.Completed, subTask2.getTaskData().getStatus());
+		assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
+
+		assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
+	}
+
+	public void setHandler(WSHumanTaskHandler handler) {
+		this.handler = handler;
+	}
+
+	public WSHumanTaskHandler getHandler() {
+		return handler;
+	}
+
+	private class TestWorkItemManager implements WorkItemManager {
+
+		private volatile boolean completed;
+		private volatile boolean aborted;
+		private volatile Map<String, Object> results;
+
+		public synchronized boolean waitTillCompleted(long time) {
+			if (!isCompleted()) {
+				try {
+					wait(time);
+				} catch (InterruptedException e) {
+					// swallow and return state of completed
+				}
+			}
+
+			return isCompleted();
+		}
+
+		public synchronized boolean waitTillAborted(long time) {
+			if (!isAborted()) {
+				try {
+					wait(time);
+				} catch (InterruptedException e) {
+					// swallow and return state of aborted
+				}
+			}
+
+			return isAborted();
+		}
+
+		public void abortWorkItem(long id) {
+			setAborted(true);
+		}
+
+		public synchronized boolean isAborted() {
+			return aborted;
+		}
+
+		private synchronized void setAborted(boolean aborted) {
+			this.aborted = aborted;
+			notifyAll();
+		}
+
+		public void completeWorkItem(long id, Map<String, Object> results) {
+			this.results = results;
+			setCompleted(true);
+		}
+
+		private synchronized void setCompleted(boolean completed) {
+			this.completed = completed;
+			notifyAll();
+		}
+
+		public synchronized boolean isCompleted() {
+			return completed;
+		}
+
+		public Map<String, Object> getResults() {
+			return results;
+		}
+
+		public void registerWorkItemHandler(String workItemName, WorkItemHandler handler) {
+		}
+
+	}
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/WSHumanTaskHandlerTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,758 +0,0 @@
-package org.drools.process.workitem.wsht;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.drools.SystemEventListenerFactory;
-import org.drools.process.instance.impl.WorkItemImpl;
-import org.drools.runtime.process.WorkItem;
-import org.drools.runtime.process.WorkItemHandler;
-import org.drools.runtime.process.WorkItemManager;
-import org.drools.task.AccessType;
-import org.drools.task.BaseTest;
-import org.drools.task.Status;
-import org.drools.task.Task;
-import org.drools.task.query.TaskSummary;
-import org.drools.task.service.ContentData;
-import org.drools.task.service.PermissionDeniedException;
-import org.drools.task.service.TaskClient;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingTaskSummaryResponseHandler;
-
-public class WSHumanTaskHandlerTest extends BaseTest {
-    private static final int DEFAULT_WAIT_TIME = 5000;
-    private static final int MANAGER_COMPLETION_WAIT_TIME = DEFAULT_WAIT_TIME;
-    private static final int MANAGER_ABORT_WAIT_TIME = DEFAULT_WAIT_TIME;
-
-    MinaTaskServer server;
-    TaskClient client;
-    WSHumanTaskHandler handler;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        server = new MinaTaskServer(taskService);
-        Thread thread = new Thread(server);
-        thread.start();
-        Thread.sleep(500);
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-        						new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-        handler = new WSHumanTaskHandler();
-    }
-
-    protected void tearDown() throws Exception {
-        handler.dispose();
-        client.disconnect();
-        server.stop();
-        super.tearDown();
-    }
-
-    public void testTask() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary task = tasks.get(0);
-        assertEquals("TaskName", task.getName());
-        assertEquals(10, task.getPriority());
-        assertEquals("Comment", task.getDescription());
-        assertEquals(Status.Reserved, task.getStatus());
-        assertEquals("Darth Vader", task.getActualOwner().getId());
-
-        System.out.println("Starting task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started task " + task.getId());
-
-        System.out.println("Completing task " + task.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete(task.getId(), "Darth Vader", null, operationResponseHandler);
-        operationResponseHandler.waitTillDone(15000);
-        System.out.println("Completed task " + task.getId());
-
-        assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
-    }
-
-    public void testTaskMultipleActors() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader, Dalai Lama");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary task = tasks.get(0);
-        assertEquals("TaskName", task.getName());
-        assertEquals(10, task.getPriority());
-        assertEquals("Comment", task.getDescription());
-        assertEquals(Status.Ready, task.getStatus());
-
-        System.out.println("Claiming task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Claimed task " + task.getId());
-
-        System.out.println("Starting task " + task.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started task " + task.getId());
-
-        System.out.println("Completing task " + task.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete(task.getId(), "Darth Vader", null, operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Completed task " + task.getId());
-
-        assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
-    }
-
-    public void testTaskGroupActors() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("GroupId", "Crusaders");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        List<String> groupIds = new ArrayList<String>();
-        groupIds.add("Crusaders");
-        client.getTasksAssignedAsPotentialOwner(null, groupIds, "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary taskSummary = tasks.get(0);
-        assertEquals("TaskName", taskSummary.getName());
-        assertEquals(10, taskSummary.getPriority());
-        assertEquals("Comment", taskSummary.getDescription());
-        assertEquals(Status.Ready, taskSummary.getStatus());
-
-        System.out.println("Claiming task " + taskSummary.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim(taskSummary.getId(), "Darth Vader", operationResponseHandler);
-        PermissionDeniedException denied = null;
-        try {
-            operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch (PermissionDeniedException e) {
-            denied = e;
-        }
-
-        assertNotNull("Should get permissed denied exception", denied);
-        System.out.println("Claimed task " + taskSummary.getId());
-
-        //Check if the parent task is InProgress
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(taskSummary.getId(), getTaskResponseHandler);
-        Task task = getTaskResponseHandler.getTask();
-        assertEquals(Status.Ready, task.getTaskData().getStatus());
-    }
-
-    public void testTaskSingleAndGroupActors() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task One");
-        workItem.setParameter("TaskName", "TaskNameOne");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("GroupId", "Crusaders");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        workItem = new WorkItemImpl();
-        workItem.setName("Human Task Two");
-        workItem.setParameter("TaskName", "TaskNameTwo");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        List<String> groupIds = new ArrayList<String>();
-        groupIds.add("Crusaders");
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", groupIds, "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(2, tasks.size());
-    }
-
-    public void testTaskFail() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary task = tasks.get(0);
-        assertEquals("TaskName", task.getName());
-        assertEquals(10, task.getPriority());
-        assertEquals("Comment", task.getDescription());
-        assertEquals(Status.Reserved, task.getStatus());
-        assertEquals("Darth Vader", task.getActualOwner().getId());
-
-        System.out.println("Starting task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started task " + task.getId());
-
-        System.out.println("Failing task " + task.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.fail(task.getId(), "Darth Vader", null, operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Failed task " + task.getId());
-
-        assertTrue(manager.waitTillAborted(MANAGER_ABORT_WAIT_TIME));
-    }
-
-    public void testTaskSkip() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary task = tasks.get(0);
-        assertEquals("TaskName", task.getName());
-        assertEquals(10, task.getPriority());
-        assertEquals("Comment", task.getDescription());
-        assertEquals(Status.Reserved, task.getStatus());
-        assertEquals("Darth Vader", task.getActualOwner().getId());
-
-        System.out.println("Skipping task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.skip(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Skipped task " + task.getId());
-
-        assertTrue(manager.waitTillAborted(MANAGER_ABORT_WAIT_TIME));
-    }
-
-    public void testTaskAbortSkippable() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        handler.abortWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(0, tasks.size());
-    }
-
-    public void testTaskAbortNotSkippable() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        workItem.setParameter("Skippable", "false");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-
-        handler.abortWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-    }
-
-    public void testTaskData() throws Exception {
-        TestWorkItemManager manager = new TestWorkItemManager();
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskName");
-        workItem.setParameter("Comment", "Comment");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        workItem.setParameter("Content", "This is the content");
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary taskSummary = tasks.get(0);
-        assertEquals("TaskName", taskSummary.getName());
-        assertEquals(10, taskSummary.getPriority());
-        assertEquals("Comment", taskSummary.getDescription());
-        assertEquals(Status.Reserved, taskSummary.getStatus());
-        assertEquals("Darth Vader", taskSummary.getActualOwner().getId());
-
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(taskSummary.getId(), getTaskResponseHandler);
-        Task task = getTaskResponseHandler.getTask();
-        assertEquals(AccessType.Inline, task.getTaskData().getDocumentAccessType());
-        long contentId = task.getTaskData().getDocumentContentId();
-        assertTrue(contentId != -1);
-        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
-        client.getContent(contentId, getContentResponseHandler);
-        ByteArrayInputStream bis = new ByteArrayInputStream(getContentResponseHandler.getContent().getContent());
-        ObjectInputStream in = new ObjectInputStream(bis);
-        Object data = in.readObject();
-        in.close();
-        assertEquals("This is the content", data);
-
-        System.out.println("Starting task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started task " + task.getId());
-
-        System.out.println("Completing task " + task.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        ContentData result = new ContentData();
-        result.setAccessType(AccessType.Inline);
-        result.setType("java.lang.String");
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        ObjectOutputStream out = new ObjectOutputStream(bos);
-        out.writeObject("This is the result");
-        out.close();
-        result.setContent(bos.toByteArray());
-        client.complete(task.getId(), "Darth Vader", result, operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Completed task " + task.getId());
-
-        assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
-        Map<String, Object> results = manager.getResults();
-        assertNotNull(results);
-        assertEquals("Darth Vader", results.get("ActorId"));
-        assertEquals("This is the result", results.get("Result"));
-    }
-
-    public void TODOtestOnAllSubTasksEndParentEndStrategy() throws Exception {
-
-        TestWorkItemManager manager = new TestWorkItemManager();
-        //Create the parent task
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskNameParent");
-        workItem.setParameter("Comment", "CommentParent");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        //Set the subtask policy
-        workItem.setParameter("SubTaskStrategies", "OnAllSubTasksEndParentEnd");
-        handler.executeWorkItem(workItem, manager);
-
-
-        Thread.sleep(500);
-
-        //Test if the task is succesfully created
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary task = tasks.get(0);
-        assertEquals("TaskNameParent", task.getName());
-        assertEquals(10, task.getPriority());
-        assertEquals("CommentParent", task.getDescription());
-        assertEquals(Status.Reserved, task.getStatus());
-        assertEquals("Darth Vader", task.getActualOwner().getId());
-
-        //Create the child task
-        workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskNameChild1");
-        workItem.setParameter("Comment", "CommentChild1");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        workItem.setParameter("ParentId", task.getId());
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        //Create the child task2
-        workItem = new WorkItemImpl();
-        workItem.setName("Human Task2");
-        workItem.setParameter("TaskName", "TaskNameChild2");
-        workItem.setParameter("Comment", "CommentChild2");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        workItem.setParameter("ParentId", task.getId());
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        //Start the parent task
-        System.out.println("Starting task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started task " + task.getId());
-
-        //Check if the parent task is InProgress
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(task.getId(), getTaskResponseHandler);
-        Task parentTask = getTaskResponseHandler.getTask();
-        assertEquals(Status.InProgress, parentTask.getTaskData().getStatus());
-        assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
-
-        //Get all the subtask created for the parent task based on the potential owner
-        responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getSubTasksAssignedAsPotentialOwner(parentTask.getId(), "Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> subTasks = responseHandler.getResults();
-        assertEquals(2, subTasks.size());
-        TaskSummary subTaskSummary1 = subTasks.get(0);
-        TaskSummary subTaskSummary2 = subTasks.get(1);
-        assertNotNull(subTaskSummary1);
-        assertNotNull(subTaskSummary2);
-
-        //Starting the sub task 1
-        System.out.println("Starting sub task " + subTaskSummary1.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(subTaskSummary1.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started sub task " + subTaskSummary1.getId());
-
-        //Starting the sub task 2
-        System.out.println("Starting sub task " + subTaskSummary2.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(subTaskSummary2.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started sub task " + subTaskSummary2.getId());
-
-        //Check if the child task 1 is InProgress
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTaskSummary1.getId(), getTaskResponseHandler);
-        Task subTask1 = getTaskResponseHandler.getTask();
-        assertEquals(Status.InProgress, subTask1.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
-
-        //Check if the child task 2 is InProgress
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTaskSummary2.getId(), getTaskResponseHandler);
-        Task subTask2 = getTaskResponseHandler.getTask();
-        assertEquals(Status.InProgress, subTask2.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
-
-        // Complete the child task 1
-        System.out.println("Completing sub task " + subTask1.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete(subTask1.getId(), "Darth Vader", null, operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Completed sub task " + subTask1.getId());
-
-        // Complete the child task 2
-        System.out.println("Completing sub task " + subTask2.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete(subTask2.getId(), "Darth Vader", null, operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Completed sub task " + subTask2.getId());
-
-        //Check if the child task 1 is Completed
-
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTask1.getId(), getTaskResponseHandler);
-        subTask1 = getTaskResponseHandler.getTask();
-        assertEquals(Status.Completed, subTask1.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
-
-        //Check if the child task 2 is Completed
-
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTask2.getId(), getTaskResponseHandler);
-        subTask2 = getTaskResponseHandler.getTask();
-        assertEquals(Status.Completed, subTask2.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
-
-        // Check is the parent task is Complete
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(parentTask.getId(), getTaskResponseHandler);
-        parentTask = getTaskResponseHandler.getTask();
-        assertEquals(Status.Completed, parentTask.getTaskData().getStatus());
-        assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
-
-        assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
-    }
-
-    public void TODOtestOnParentAbortAllSubTasksEndStrategy() throws Exception {
-
-        TestWorkItemManager manager = new TestWorkItemManager();
-        //Create the parent task
-        WorkItemImpl workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskNameParent");
-        workItem.setParameter("Comment", "CommentParent");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        //Set the subtask policy
-        workItem.setParameter("SubTaskStrategies", "OnParentAbortAllSubTasksEnd");
-        handler.executeWorkItem(workItem, manager);
-
-
-        Thread.sleep(500);
-
-        //Test if the task is succesfully created
-        BlockingTaskSummaryResponseHandler responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner("Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> tasks = responseHandler.getResults();
-        assertEquals(1, tasks.size());
-        TaskSummary task = tasks.get(0);
-        assertEquals("TaskNameParent", task.getName());
-        assertEquals(10, task.getPriority());
-        assertEquals("CommentParent", task.getDescription());
-        assertEquals(Status.Reserved, task.getStatus());
-        assertEquals("Darth Vader", task.getActualOwner().getId());
-
-        //Create the child task
-        workItem = new WorkItemImpl();
-        workItem.setName("Human Task");
-        workItem.setParameter("TaskName", "TaskNameChild1");
-        workItem.setParameter("Comment", "CommentChild1");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        workItem.setParameter("ParentId", task.getId());
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        //Create the child task2
-        workItem = new WorkItemImpl();
-        workItem.setName("Human Task2");
-        workItem.setParameter("TaskName", "TaskNameChild2");
-        workItem.setParameter("Comment", "CommentChild2");
-        workItem.setParameter("Priority", "10");
-        workItem.setParameter("ActorId", "Darth Vader");
-        workItem.setParameter("ParentId", task.getId());
-        handler.executeWorkItem(workItem, manager);
-
-        Thread.sleep(500);
-
-        //Start the parent task
-        System.out.println("Starting task " + task.getId());
-        BlockingTaskOperationResponseHandler operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(task.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started task " + task.getId());
-
-        //Check if the parent task is InProgress
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(task.getId(), getTaskResponseHandler);
-        Task parentTask = getTaskResponseHandler.getTask();
-        assertEquals(Status.InProgress, parentTask.getTaskData().getStatus());
-        assertEquals(users.get("darth"), parentTask.getTaskData().getActualOwner());
-
-        //Get all the subtask created for the parent task based on the potential owner
-        responseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getSubTasksAssignedAsPotentialOwner(parentTask.getId(), "Darth Vader", "en-UK", responseHandler);
-        List<TaskSummary> subTasks = responseHandler.getResults();
-        assertEquals(2, subTasks.size());
-        TaskSummary subTaskSummary1 = subTasks.get(0);
-        TaskSummary subTaskSummary2 = subTasks.get(1);
-        assertNotNull(subTaskSummary1);
-        assertNotNull(subTaskSummary2);
-
-        //Starting the sub task 1
-        System.out.println("Starting sub task " + subTaskSummary1.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(subTaskSummary1.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started sub task " + subTaskSummary1.getId());
-
-        //Starting the sub task 2
-        System.out.println("Starting sub task " + subTaskSummary2.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.start(subTaskSummary2.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Started sub task " + subTaskSummary2.getId());
-
-        //Check if the child task 1 is InProgress
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTaskSummary1.getId(), getTaskResponseHandler);
-        Task subTask1 = getTaskResponseHandler.getTask();
-        assertEquals(Status.InProgress, subTask1.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
-
-        //Check if the child task 2 is InProgress
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTaskSummary2.getId(), getTaskResponseHandler);
-        Task subTask2 = getTaskResponseHandler.getTask();
-        assertEquals(Status.InProgress, subTask2.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
-
-        // Complete the parent task
-        System.out.println("Completing parent task " + parentTask.getId());
-        operationResponseHandler = new BlockingTaskOperationResponseHandler();
-        client.skip(parentTask.getId(), "Darth Vader", operationResponseHandler);
-        operationResponseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        System.out.println("Completed parent task " + parentTask.getId());
-
-        //Check if the child task 1 is Completed
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTaskSummary1.getId(), getTaskResponseHandler);
-        subTask1 = getTaskResponseHandler.getTask();
-        assertEquals(Status.Completed, subTask1.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask1.getTaskData().getActualOwner());
-
-        //Check if the child task 2 is Completed
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();
-        client.getTask(subTaskSummary2.getId(), getTaskResponseHandler);
-        subTask2 = getTaskResponseHandler.getTask();
-        assertEquals(Status.Completed, subTask2.getTaskData().getStatus());
-        assertEquals(users.get("darth"), subTask2.getTaskData().getActualOwner());
-
-        assertTrue(manager.waitTillCompleted(MANAGER_COMPLETION_WAIT_TIME));
-    }
-
-    private class TestWorkItemManager implements WorkItemManager {
-
-        private volatile boolean completed;
-        private volatile boolean aborted;
-        private volatile Map<String, Object> results;
-
-        public synchronized boolean waitTillCompleted(long time) {
-            if (!isCompleted()) {
-                try {
-                    wait(time);
-                } catch (InterruptedException e) {
-                    // swallow and return state of completed
-                }
-            }
-
-            return isCompleted();
-        }
-
-        public synchronized boolean waitTillAborted(long time) {
-            if (!isAborted()) {
-                try {
-                    wait(time);
-                } catch (InterruptedException e) {
-                    // swallow and return state of aborted
-                }
-            }
-
-            return isAborted();
-        }
-
-        public void abortWorkItem(long id) {
-            setAborted(true);
-        }
-
-        public synchronized boolean isAborted() {
-            return aborted;
-        }
-
-        private synchronized void setAborted(boolean aborted) {
-            this.aborted = aborted;
-            notifyAll();
-        }
-
-        public void completeWorkItem(long id, Map<String, Object> results) {
-            this.results = results;
-            setCompleted(true);
-        }
-
-        private synchronized void setCompleted(boolean completed) {
-            this.completed = completed;
-            notifyAll();
-        }
-
-        public synchronized boolean isCompleted() {
-            return completed;
-        }
-
-        public WorkItem getWorkItem(long id) {
-            return null;
-        }
-
-        public Set<WorkItem> getWorkItems() {
-            return null;
-        }
-
-        public Map<String, Object> getResults() {
-            return results;
-        }
-
-        public void internalAbortWorkItem(long id) {
-        }
-
-        public void internalAddWorkItem(WorkItem workItem) {
-        }
-
-        public void internalExecuteWorkItem(WorkItem workItem) {
-        }
-
-        public void registerWorkItemHandler(String workItemName, WorkItemHandler handler) {
-        }
-
-    }
-}

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/hornetq/WSHumanTaskHandlerHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/hornetq/WSHumanTaskHandlerHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/hornetq/WSHumanTaskHandlerHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,37 @@
+package org.drools.process.workitem.wsht.hornetq;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.process.workitem.wsht.WSHumanTaskHandler;
+import org.drools.process.workitem.wsht.WSHumanTaskHandlerBaseTest;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.hornetq.HornetQTaskClientConnector;
+import org.drools.task.service.hornetq.HornetQTaskServer;
+import org.drools.task.service.hornetq.TaskHornetQClientHandler;
+
+public class WSHumanTaskHandlerHornetQTest extends WSHumanTaskHandlerBaseTest {
+
+	private HornetQTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new HornetQTaskServer(taskService, 5446);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+		setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+								new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 5446);
+		WSHumanTaskHandler handler = new WSHumanTaskHandler();
+		handler.setClient(getClient());
+		setHandler(handler);
+	}
+
+	protected void tearDown() throws Exception {
+		getHandler().dispose();
+		getClient().disconnect();
+		server.stop();
+		super.tearDown();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/hornetq/WSHumanTaskHandlerHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/mina/WSHumanTaskHandlerMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/mina/WSHumanTaskHandlerMinaTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/mina/WSHumanTaskHandlerMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,35 @@
+package org.drools.process.workitem.wsht.mina;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.process.workitem.wsht.WSHumanTaskHandler;
+import org.drools.process.workitem.wsht.WSHumanTaskHandlerBaseTest;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+
+public class WSHumanTaskHandlerMinaTest extends WSHumanTaskHandlerBaseTest {
+
+	private MinaTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new MinaTaskServer(taskService);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+		setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+								new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 9123);
+		setHandler(new WSHumanTaskHandler());
+	}
+
+	protected void tearDown() throws Exception {
+		getHandler().dispose();
+		getClient().disconnect();
+		server.stop();
+		super.tearDown();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/process/workitem/wsht/mina/WSHumanTaskHandlerMinaTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/QueryTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/QueryTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/QueryTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -2,15 +2,13 @@
 
 import java.io.InputStreamReader;
 import java.io.Reader;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
 import org.apache.commons.collections.map.HashedMap;
 import org.drools.task.query.DeadlineSummary;
-import org.drools.task.service.TaskServiceEscalationTest.MockEscalatedDeadlineHandler;
+import org.drools.task.service.TaskServiceEscalationBaseTest.MockEscalatedDeadlineHandler;
 
 public class QueryTest extends BaseTest {
 

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,422 @@
+package org.drools.task.service;
+
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.util.Date;
+import java.util.Map;
+
+import javax.mail.BodyPart;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+import javax.mail.internet.MimeMultipart;
+import javax.mail.internet.MimeMessage.RecipientType;
+
+import org.apache.commons.collections.map.HashedMap;
+import org.drools.task.BaseTest;
+import org.drools.task.MockUserInfo;
+import org.drools.task.Task;
+import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
+import org.subethamail.wiser.Wiser;
+import org.subethamail.wiser.WiserMessage;
+
+public abstract class IcalBaseTest extends BaseTest {
+
+	private TaskClient client;
+	private Wiser wiser;
+	private String emailHost;
+	private String emailPort;    
+
+	public void testSendWithStartandEndDeadline() throws Exception {
+        Map vars = new HashedMap();
+        vars.put("users", users);
+        vars.put("groups", groups);
+        vars.put("now", new Date());
+
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
+        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
+        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')],";
+        str += "deadlines = (with (new Deadlines() ) {";
+        str += "    startDeadlines = [ ";
+        str += "       (with (new Deadline()) {";
+        str += "           date = now";
+        str += "       } ) ],";
+        str += "    endDeadlines = [";
+        str += "        (with (new Deadline()) {";
+        str += "             date = new Date( now.time + ( 1000 * 60 * 60 * 24 ) )"; // set to tomorrow
+        str += "        } ) ]";
+        str += "} ) })";
+
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put( users.get( "tony" ),
+                                  "tony at domain.com" );
+        userInfo.getEmails().put( users.get( "steve" ),
+                                  "steve at domain.com" );
+
+        userInfo.getLanguages().put( users.get( "tony" ),
+                                     "en-UK" );
+        userInfo.getLanguages().put( users.get( "steve" ),
+                                     "en-UK" );
+        taskService.setUserinfo( userInfo );
+
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = (Task) eval( new StringReader( str ),
+                                 vars );
+        getClient().addTask( task, null,
+                        addTaskResponseHandler );
+
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        getClient().claim( taskId,
+                      users.get( "steve" ).getId(),
+                      responseHandler );
+        responseHandler.waitTillDone( 5000 );
+
+        assertEquals( 2,
+                      getWiser().getMessages().size() );
+        
+        assertEquals( "steve at domain.com", getWiser().getMessages().get( 0 ).getEnvelopeReceiver() );
+        assertEquals( "steve at domain.com", getWiser().getMessages().get( 1 ).getEnvelopeReceiver() );
+
+        String subject = "Summary\n-------\n\nThis is my task subject\n\n";
+        String description = "Description\n-----------\n\nThis is my task description";
+
+        MimeMessage msg = ((WiserMessage) getWiser().getMessages().get( 0 )).getMimeMessage();
+        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
+                                      msg.getContentType(),
+                                      0,
+                                      47 );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
+        assertEquals( "steve at domain.com",
+                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
+        assertEquals( "Task Assignment Start Event: This is my task name",
+                      msg.getSubject() );
+        
+        MimeMultipart multiPart = (MimeMultipart) msg.getContent();
+                        
+        BodyPart messageBodyPart = multiPart.getBodyPart( 0 );
+        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
+        String content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
+        assertEqualsIgnoreWhitespace( subject + description, content );
+        
+        messageBodyPart = multiPart.getBodyPart( 1 );
+        assertEquals( "text/calendar; charset=UTF8; name=ical-Start-1.ics", messageBodyPart.getDataHandler().getContentType() );
+        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
+        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
+        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task Start : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
+        
+        
+        msg = ((WiserMessage) getWiser().getMessages().get( 1 )).getMimeMessage();
+        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
+                                      msg.getContentType(),
+                                      0,
+                                      47 );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
+        assertEquals( "steve at domain.com",
+                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
+        assertEquals( "Task Assignment End Event: This is my task name",
+                      msg.getSubject() );
+        
+        multiPart = (MimeMultipart) msg.getContent();
+                        
+        messageBodyPart = multiPart.getBodyPart( 0 );
+        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
+        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
+        assertEqualsIgnoreWhitespace( subject + description, content );
+        
+        messageBodyPart = multiPart.getBodyPart( 1 );
+        assertEquals( "text/calendar; charset=UTF8; name=ical-End-1.ics", messageBodyPart.getDataHandler().getContentType() );
+        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
+        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
+        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task End : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
+    }
+    
+    public void testSendWithStartDeadline() throws Exception {
+        Map vars = new HashedMap();
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+        vars.put( "now", new Date() );
+
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
+        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
+        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')],";
+        str += "deadlines = (with (new Deadlines() ) {";
+        str += "    startDeadlines = [ ";
+        str += "       (with (new Deadline()) {";
+        str += "           date = now";
+        str += "       } ) ]";
+        str += "} ) })";
+
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put( users.get( "tony" ),
+                                  "tony at domain.com" );
+        userInfo.getEmails().put( users.get( "steve" ),
+                                  "steve at domain.com" );
+
+        userInfo.getLanguages().put( users.get( "tony" ),
+                                     "en-UK" );
+        userInfo.getLanguages().put( users.get( "steve" ),
+                                     "en-UK" );
+        taskService.setUserinfo( userInfo );
+
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = (Task) eval( new StringReader( str ),
+                                 vars );
+        getClient().addTask( task, null,
+                        addTaskResponseHandler );
+
+        long taskId = addTaskResponseHandler.getTaskId();
+
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        getClient().claim( taskId,
+                      users.get( "steve" ).getId(),
+                      responseHandler );
+        responseHandler.waitTillDone( 5000 );
+
+        assertEquals( 1,
+                      getWiser().getMessages().size() );
+
+        assertEquals( "steve at domain.com", getWiser().getMessages().get( 0 ).getEnvelopeReceiver() );
+
+        String subject = "Summary\n-------\n\nThis is my task subject\n\n";
+        String description = "Description\n-----------\n\nThis is my task description";
+
+        MimeMessage msg = ((WiserMessage) getWiser().getMessages().get( 0 )).getMimeMessage();
+        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
+                                      msg.getContentType(),
+                                      0,
+                                      47 );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
+        assertEquals( "steve at domain.com",
+                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
+        assertEquals( "Task Assignment Start Event: This is my task name",
+                      msg.getSubject() );
+        
+        MimeMultipart multiPart = (MimeMultipart) msg.getContent();
+                        
+        BodyPart messageBodyPart = multiPart.getBodyPart( 0 );
+        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
+        String content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
+        assertEqualsIgnoreWhitespace( subject + description, content );
+        
+        messageBodyPart = multiPart.getBodyPart( 1 );
+        assertEquals( "text/calendar; charset=UTF8; name=ical-Start-1.ics", messageBodyPart.getDataHandler().getContentType() );
+        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
+        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
+        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task Start : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
+    }    
+    
+    public void testSendWithEndDeadline() throws Exception {
+        Map vars = new HashedMap();
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+        vars.put( "now", new Date() );
+
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
+        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
+        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')],";
+        str += "deadlines = (with (new Deadlines() ) {";
+        str += "    endDeadlines = [";
+        str += "        (with (new Deadline()) {";
+        str += "             date = new Date( now.time + ( 1000 * 60 * 60 * 24 ) )"; // set to tomorrow
+        str += "        } ) ]";
+        str += "} ) })";
+
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put( users.get( "tony" ),
+                                  "tony at domain.com" );
+        userInfo.getEmails().put( users.get( "steve" ),
+                                  "steve at domain.com" );
+
+        userInfo.getLanguages().put( users.get( "tony" ),
+                                     "en-UK" );
+        userInfo.getLanguages().put( users.get( "steve" ),
+                                     "en-UK" );
+        taskService.setUserinfo( userInfo );
+
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = (Task) eval( new StringReader( str ),
+                                 vars );
+        getClient().addTask( task, null,
+                        addTaskResponseHandler );
+
+        long taskId = addTaskResponseHandler.getTaskId();
+
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        getClient().claim( taskId,
+                      users.get( "steve" ).getId(),
+                      responseHandler );
+
+        responseHandler.waitTillDone( 5000 );
+
+        assertEquals( 1,
+                      getWiser().getMessages().size() );
+        
+        assertEquals( "steve at domain.com", getWiser().getMessages().get( 0 ).getEnvelopeReceiver() );
+
+        String subject = "Summary\n-------\n\nThis is my task subject\n\n";
+        String description = "Description\n-----------\n\nThis is my task description";
+                
+        MimeMessage msg = ((WiserMessage) getWiser().getMessages().get( 0 )).getMimeMessage();
+        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
+                                      msg.getContentType(),
+                                      0,
+                                      47 );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
+        assertEquals( "tony at domain.com",
+                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
+        assertEquals( "steve at domain.com",
+                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
+        assertEquals( "Task Assignment End Event: This is my task name",
+                      msg.getSubject() );
+        
+        MimeMultipart multiPart = (MimeMultipart) msg.getContent();
+                        
+        BodyPart messageBodyPart = multiPart.getBodyPart( 0 );
+        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
+        String content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
+        assertEqualsIgnoreWhitespace( subject + description, content );
+        
+        messageBodyPart = multiPart.getBodyPart( 1 );
+        assertEquals( "text/calendar; charset=UTF8; name=ical-End-1.ics", messageBodyPart.getDataHandler().getContentType() );
+        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
+        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
+        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task End : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
+    }
+    
+    public void testSendWithNoDeadline() throws Exception {
+        Map vars = new HashedMap();
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+        vars.put( "now", new Date() );
+
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
+        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
+        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')]";
+        str += "})";
+
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put( users.get( "tony" ),
+                                  "tony at domain.com" );
+        userInfo.getEmails().put( users.get( "steve" ),
+                                  "steve at domain.com" );
+
+        userInfo.getLanguages().put( users.get( "tony" ),
+                                     "en-UK" );
+        userInfo.getLanguages().put( users.get( "steve" ),
+                                     "en-UK" );
+        taskService.setUserinfo( userInfo );
+
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = (Task) eval( new StringReader( str ),
+                                 vars );
+        getClient().addTask( task, null,
+                        addTaskResponseHandler );
+
+        long taskId = addTaskResponseHandler.getTaskId();
+
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        getClient().claim( taskId,
+                      users.get( "steve" ).getId(),
+                      responseHandler );
+
+        responseHandler.waitTillDone( 5000 );
+
+        assertEquals( 0,
+                      getWiser().getMessages().size() );        
+    }       
+    
+    private static void assertEqualsIgnoreWhitespace(final String expected,
+                                                     final String actual) {
+        assertEqualsIgnoreWhitespace(expected, actual, 0, actual.length());
+    }
+
+    private static void assertEqualsIgnoreWhitespace(final String expected,
+                                                     final String actual,
+                                                     int beginIndex,
+                                                     int endIndex) {
+        final String cleanExpected = expected.replaceAll( "\\s+",
+                                                          "" ).replaceAll( "\\n", "" ).replaceAll( "\\r", "" );
+        
+        final String cleanActual = actual.substring( beginIndex,
+                                                     endIndex ).replaceAll( "\\s+",
+                                                      "" ).replaceAll( "\\n", "" ).replaceAll( "\\r", "" );
+        assertEquals( cleanExpected,
+                      cleanActual );
+    } 
+    
+    private static byte[] getBytes(InputStream inputStream) throws Exception {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
+        byte[] bytes = new byte[512];
+     
+        // Read bytes from the input stream in bytes.length-sized chunks and write
+        // them into the output stream
+        int readBytes;
+        while ((readBytes = inputStream.read(bytes)) > 0) {
+            outputStream.write(bytes, 0, readBytes);
+        }
+     
+        // Convert the contents of the output stream into a byte array
+        byte[] byteData = outputStream.toByteArray();
+        
+        // Close the streams
+        inputStream.close();
+        outputStream.close();
+     
+        return byteData;
+    }
+
+    public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+
+	public void setWiser(Wiser wiser) {
+		this.wiser = wiser;
+	}
+
+	public Wiser getWiser() {
+		return wiser;
+	}
+
+	public void setEmailHost(String emailHost) {
+		this.emailHost = emailHost;
+	}
+
+	public String getEmailHost() {
+		return emailHost;
+	}
+
+	public void setEmailPort(String emailPort) {
+		this.emailPort = emailPort;
+	}
+
+	public String getEmailPort() {
+		return emailPort;
+	}
+
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/IcalTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,441 +0,0 @@
-package org.drools.task.service;
-
-import java.io.ByteArrayOutputStream;
-import java.io.InputStream;
-import java.io.StringReader;
-import java.util.Date;
-import java.util.Map;
-
-import javax.mail.BodyPart;
-import javax.mail.internet.InternetAddress;
-import javax.mail.internet.MimeMessage;
-import javax.mail.internet.MimeMultipart;
-import javax.mail.internet.MimeMessage.RecipientType;
-
-import org.apache.commons.collections.map.HashedMap;
-import org.drools.SystemEventListenerFactory;
-import org.drools.task.BaseTest;
-import org.drools.task.MockUserInfo;
-import org.drools.task.Task;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
-import org.drools.util.ChainedProperties;
-import org.drools.util.ClassLoaderUtil;
-import org.subethamail.wiser.Wiser;
-import org.subethamail.wiser.WiserMessage;
-
-public class IcalTest extends BaseTest {
-    MinaTaskServer server;
-    TaskClient client;
-
-    Wiser          wiser;
-    
-    String emailHost;
-    String emailPort;    
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        
-        ChainedProperties props = new ChainedProperties( "process.email.conf", ClassLoaderUtil.getClassLoader( null, getClass(), false ) );
-        emailHost = props.getProperty( "host", "locahost" );
-        emailPort = props.getProperty( "port", "2345" );        
-        
-        server = new MinaTaskServer( taskService );
-        Thread thread = new Thread( server );
-        thread.start();
-        Thread.sleep( 500 );
-
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-        						new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-
-        wiser = new Wiser();
-        wiser.setHostname( emailHost );
-        wiser.setPort( Integer.parseInt( emailPort ) );         
-        wiser.start();
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-        client.disconnect();
-        server.stop();
-
-        wiser.stop();
-    }
-
-    public void testSendWithStartandEndDeadline() throws Exception {
-        Map vars = new HashedMap();
-        vars.put( "users",
-                  users );
-        vars.put( "groups",
-                  groups );
-        vars.put( "now",
-                  new Date() );
-
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
-        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
-        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')],";
-        str += "deadlines = (with (new Deadlines() ) {";
-        str += "    startDeadlines = [ ";
-        str += "       (with (new Deadline()) {";
-        str += "           date = now";
-        str += "       } ) ],";
-        str += "    endDeadlines = [";
-        str += "        (with (new Deadline()) {";
-        str += "             date = new Date( now.time + ( 1000 * 60 * 60 * 24 ) )"; // set to tomorrow
-        str += "        } ) ]";
-        str += "} ) })";
-
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get( "tony" ),
-                                  "tony at domain.com" );
-        userInfo.getEmails().put( users.get( "steve" ),
-                                  "steve at domain.com" );
-
-        userInfo.getLanguages().put( users.get( "tony" ),
-                                     "en-UK" );
-        userInfo.getLanguages().put( users.get( "steve" ),
-                                     "en-UK" );
-        taskService.setUserinfo( userInfo );
-
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = (Task) eval( new StringReader( str ),
-                                 vars );
-        client.addTask( task, null,
-                        addTaskResponseHandler );
-
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId,
-                      users.get( "steve" ).getId(),
-                      responseHandler );
-        responseHandler.waitTillDone( 5000 );
-
-        assertEquals( 2,
-                      wiser.getMessages().size() );
-        
-        assertEquals( "steve at domain.com", wiser.getMessages().get( 0 ).getEnvelopeReceiver() );
-        assertEquals( "steve at domain.com", wiser.getMessages().get( 1 ).getEnvelopeReceiver() );
-
-        String subject = "Summary\n-------\n\nThis is my task subject\n\n";
-        String description = "Description\n-----------\n\nThis is my task description";
-
-        MimeMessage msg = ((WiserMessage) wiser.getMessages().get( 0 )).getMimeMessage();
-        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
-                                      msg.getContentType(),
-                                      0,
-                                      47 );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
-        assertEquals( "steve at domain.com",
-                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
-        assertEquals( "Task Assignment Start Event: This is my task name",
-                      msg.getSubject() );
-        
-        MimeMultipart multiPart = (MimeMultipart) msg.getContent();
-                        
-        BodyPart messageBodyPart = multiPart.getBodyPart( 0 );
-        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
-        String content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
-        assertEqualsIgnoreWhitespace( subject + description, content );
-        
-        messageBodyPart = multiPart.getBodyPart( 1 );
-        assertEquals( "text/calendar; charset=UTF8; name=ical-Start-1.ics", messageBodyPart.getDataHandler().getContentType() );
-        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
-        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
-        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task Start : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
-        
-        
-        msg = ((WiserMessage) wiser.getMessages().get( 1 )).getMimeMessage();
-        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
-                                      msg.getContentType(),
-                                      0,
-                                      47 );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
-        assertEquals( "steve at domain.com",
-                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
-        assertEquals( "Task Assignment End Event: This is my task name",
-                      msg.getSubject() );
-        
-        multiPart = (MimeMultipart) msg.getContent();
-                        
-        messageBodyPart = multiPart.getBodyPart( 0 );
-        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
-        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
-        assertEqualsIgnoreWhitespace( subject + description, content );
-        
-        messageBodyPart = multiPart.getBodyPart( 1 );
-        assertEquals( "text/calendar; charset=UTF8; name=ical-End-1.ics", messageBodyPart.getDataHandler().getContentType() );
-        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
-        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
-        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task End : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
-    }
-    
-    public void testSendWithStartDeadline() throws Exception {
-        Map vars = new HashedMap();
-        vars.put( "users",
-                  users );
-        vars.put( "groups",
-                  groups );
-        vars.put( "now",
-                  new Date() );
-
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
-        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
-        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')],";
-        str += "deadlines = (with (new Deadlines() ) {";
-        str += "    startDeadlines = [ ";
-        str += "       (with (new Deadline()) {";
-        str += "           date = now";
-        str += "       } ) ]";
-        str += "} ) })";
-
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get( "tony" ),
-                                  "tony at domain.com" );
-        userInfo.getEmails().put( users.get( "steve" ),
-                                  "steve at domain.com" );
-
-        userInfo.getLanguages().put( users.get( "tony" ),
-                                     "en-UK" );
-        userInfo.getLanguages().put( users.get( "steve" ),
-                                     "en-UK" );
-        taskService.setUserinfo( userInfo );
-
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = (Task) eval( new StringReader( str ),
-                                 vars );
-        client.addTask( task, null,
-                        addTaskResponseHandler );
-
-        long taskId = addTaskResponseHandler.getTaskId();
-
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId,
-                      users.get( "steve" ).getId(),
-                      responseHandler );
-        responseHandler.waitTillDone( 5000 );
-
-        assertEquals( 1,
-                      wiser.getMessages().size() );
-
-        assertEquals( "steve at domain.com", wiser.getMessages().get( 0 ).getEnvelopeReceiver() );
-
-        String subject = "Summary\n-------\n\nThis is my task subject\n\n";
-        String description = "Description\n-----------\n\nThis is my task description";
-
-        MimeMessage msg = ((WiserMessage) wiser.getMessages().get( 0 )).getMimeMessage();
-        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
-                                      msg.getContentType(),
-                                      0,
-                                      47 );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
-        assertEquals( "steve at domain.com",
-                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
-        assertEquals( "Task Assignment Start Event: This is my task name",
-                      msg.getSubject() );
-        
-        MimeMultipart multiPart = (MimeMultipart) msg.getContent();
-                        
-        BodyPart messageBodyPart = multiPart.getBodyPart( 0 );
-        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
-        String content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
-        assertEqualsIgnoreWhitespace( subject + description, content );
-        
-        messageBodyPart = multiPart.getBodyPart( 1 );
-        assertEquals( "text/calendar; charset=UTF8; name=ical-Start-1.ics", messageBodyPart.getDataHandler().getContentType() );
-        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
-        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
-        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task Start : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
-    }    
-    
-    public void testSendWithEndDeadline() throws Exception {
-        Map vars = new HashedMap();
-        vars.put( "users",
-                  users );
-        vars.put( "groups",
-                  groups );
-        vars.put( "now",
-                  new Date() );
-
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
-        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
-        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')],";
-        str += "deadlines = (with (new Deadlines() ) {";
-        str += "    endDeadlines = [";
-        str += "        (with (new Deadline()) {";
-        str += "             date = new Date( now.time + ( 1000 * 60 * 60 * 24 ) )"; // set to tomorrow
-        str += "        } ) ]";
-        str += "} ) })";
-
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get( "tony" ),
-                                  "tony at domain.com" );
-        userInfo.getEmails().put( users.get( "steve" ),
-                                  "steve at domain.com" );
-
-        userInfo.getLanguages().put( users.get( "tony" ),
-                                     "en-UK" );
-        userInfo.getLanguages().put( users.get( "steve" ),
-                                     "en-UK" );
-        taskService.setUserinfo( userInfo );
-
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = (Task) eval( new StringReader( str ),
-                                 vars );
-        client.addTask( task, null,
-                        addTaskResponseHandler );
-
-        long taskId = addTaskResponseHandler.getTaskId();
-
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId,
-                      users.get( "steve" ).getId(),
-                      responseHandler );
-
-        responseHandler.waitTillDone( 5000 );
-
-        assertEquals( 1,
-                      wiser.getMessages().size() );
-        
-        assertEquals( "steve at domain.com", wiser.getMessages().get( 0 ).getEnvelopeReceiver() );
-
-        String subject = "Summary\n-------\n\nThis is my task subject\n\n";
-        String description = "Description\n-----------\n\nThis is my task description";
-                
-        MimeMessage msg = ((WiserMessage) wiser.getMessages().get( 0 )).getMimeMessage();
-        assertEqualsIgnoreWhitespace( "multipart/alternative;boundary=\"----=_Part_",
-                                      msg.getContentType(),
-                                      0,
-                                      47 );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getFrom()[0]).getAddress() );
-        assertEquals( "tony at domain.com",
-                      ((InternetAddress) msg.getReplyTo()[0]).getAddress() );
-        assertEquals( "steve at domain.com",
-                      ((InternetAddress) msg.getRecipients( RecipientType.TO )[0]).getAddress() );
-        assertEquals( "Task Assignment End Event: This is my task name",
-                      msg.getSubject() );
-        
-        MimeMultipart multiPart = (MimeMultipart) msg.getContent();
-                        
-        BodyPart messageBodyPart = multiPart.getBodyPart( 0 );
-        assertEquals( "text/plain; charset=UTF8;", messageBodyPart.getDataHandler().getContentType() );
-        String content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );        
-        assertEqualsIgnoreWhitespace( subject + description, content );
-        
-        messageBodyPart = multiPart.getBodyPart( 1 );
-        assertEquals( "text/calendar; charset=UTF8; name=ical-End-1.ics", messageBodyPart.getDataHandler().getContentType() );
-        content = new String( getBytes( messageBodyPart.getDataHandler().getInputStream() ) );
-        assertEqualsIgnoreWhitespace( "BEGIN:VCALENDARPRODID:-//iCal4j 1.0//ENCALSCALE:GREGORIANVERSION:2.0METHOD:REQUESTBEGIN:VEVENTDTSTART;TZID=UTC:", content.substring( 0, 123) );           
-        assertEqualsIgnoreWhitespace( "SUMMARY:\"Task End : This is my task subject\"DESCRIPTION:\"This is my task description\"PRIORITY:55END:VEVENTEND:VCALENDAR", content.substring( content.length()-131, content.length()) );
-    }
-    
-    public void testSendWithNoDeadline() throws Exception {
-        Map vars = new HashedMap();
-        vars.put( "users",
-                  users );
-        vars.put( "groups",
-                  groups );
-        vars.put( "now",
-                  new Date() );
-
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { createdOn = now, createdBy = users['tony'], activationTime = now}), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) {potentialOwners = [users['steve' ], users['tony' ]]}), ";
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')],";
-        str += "subjects = [ new I18NText( 'en-UK', 'This is my task subject')],";
-        str += "descriptions = [ new I18NText( 'en-UK', 'This is my task description')]";
-        str += "})";
-
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get( "tony" ),
-                                  "tony at domain.com" );
-        userInfo.getEmails().put( users.get( "steve" ),
-                                  "steve at domain.com" );
-
-        userInfo.getLanguages().put( users.get( "tony" ),
-                                     "en-UK" );
-        userInfo.getLanguages().put( users.get( "steve" ),
-                                     "en-UK" );
-        taskService.setUserinfo( userInfo );
-
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = (Task) eval( new StringReader( str ),
-                                 vars );
-        client.addTask( task, null,
-                        addTaskResponseHandler );
-
-        long taskId = addTaskResponseHandler.getTaskId();
-
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId,
-                      users.get( "steve" ).getId(),
-                      responseHandler );
-
-        responseHandler.waitTillDone( 5000 );
-
-        assertEquals( 0,
-                      wiser.getMessages().size() );        
-    }       
-    
-    private static void assertEqualsIgnoreWhitespace(final String expected,
-                                                     final String actual) {
-        assertEqualsIgnoreWhitespace(expected, actual, 0, actual.length());
-    }
-
-    private static void assertEqualsIgnoreWhitespace(final String expected,
-                                                     final String actual,
-                                                     int beginIndex,
-                                                     int endIndex) {
-        final String cleanExpected = expected.replaceAll( "\\s+",
-                                                          "" ).replaceAll( "\\n", "" ).replaceAll( "\\r", "" );
-        
-        final String cleanActual = actual.substring( beginIndex,
-                                                     endIndex ).replaceAll( "\\s+",
-                                                      "" ).replaceAll( "\\n", "" ).replaceAll( "\\r", "" );
-        assertEquals( cleanExpected,
-                      cleanActual );
-    } 
-    
-    private static byte[] getBytes(InputStream inputStream) throws Exception {
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(1024);
-        byte[] bytes = new byte[512];
-     
-        // Read bytes from the input stream in bytes.length-sized chunks and write
-        // them into the output stream
-        int readBytes;
-        while ((readBytes = inputStream.read(bytes)) > 0) {
-            outputStream.write(bytes, 0, readBytes);
-        }
-     
-        // Convert the contents of the output stream into a byte array
-        byte[] byteData = outputStream.toByteArray();
-        
-        // Close the streams
-        inputStream.close();
-        outputStream.close();
-     
-        return byteData;
-
-    }
-
-}

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,177 @@
+package org.drools.task.service;
+
+import java.io.StringReader;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.collections.map.HashedMap;
+import org.drools.eventmessaging.EventKey;
+import org.drools.eventmessaging.Payload;
+import org.drools.task.BaseTest;
+import org.drools.task.Status;
+import org.drools.task.Task;
+import org.drools.task.event.TaskCompletedEvent;
+import org.drools.task.event.TaskEventKey;
+import org.drools.task.query.TaskSummary;
+import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingEventResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskSummaryResponseHandler;
+
+public abstract class TaskLifeCycleBaseTest extends BaseTest {
+	
+    private TaskClient client;
+
+    @SuppressWarnings("unchecked")
+	public void testLifeCycle() throws Exception {      
+        Map<String, Object> vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );                
+
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { workItemId = 1 } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba']], }),";                        
+//        str += "descriptions = [ new I18NText( 'en-UK', 'This is my description')], ";
+//        str += "subjects = [ new I18NText( 'en-UK', 'This is my subject')], ";
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId );           
+        BlockingEventResponseHandler handler = new BlockingEventResponseHandler(); 
+        client.registerForEvent( key, true, handler );
+        
+        BlockingTaskSummaryResponseHandler taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        List<TaskSummary> tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(1, tasks.size());
+        assertEquals(Status.Reserved, tasks.get(0).getStatus());
+        
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "bobba" ).getId(), responseHandler );  
+
+        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(1, tasks.size());
+        assertEquals(Status.InProgress, tasks.get(0).getStatus());
+        
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );
+        
+        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(0, tasks.size());
+        
+        Payload payload = handler.getPayload();
+        TaskCompletedEvent event = ( TaskCompletedEvent ) payload.get();
+        assertNotNull( event );
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Completed , task1.getTaskData().getStatus() );         
+    }
+  
+    @SuppressWarnings("unchecked")
+	public void testLifeCycleMultipleTasks() throws Exception {      
+        Map<String, Object> vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );                
+
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { workItemId = 1 } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba']], }),";                        
+        str += "descriptions = [ new I18NText( 'en-UK', 'This is my description')], ";
+        str += "subjects = [ new I18NText( 'en-UK', 'This is my subject')], ";
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId );           
+        BlockingEventResponseHandler handler = new BlockingEventResponseHandler(); 
+        client.registerForEvent( key, true, handler );
+        
+        BlockingTaskSummaryResponseHandler taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        List<TaskSummary> tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(1, tasks.size());
+        assertEquals(Status.Reserved, tasks.get(0).getStatus());
+        
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "bobba" ).getId(), responseHandler );  
+
+        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(1, tasks.size());
+        assertEquals(Status.InProgress, tasks.get(0).getStatus());
+        
+        BlockingAddTaskResponseHandler addTaskResponseHandler2 = new BlockingAddTaskResponseHandler();
+        Task task2 = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task2, null, addTaskResponseHandler2 );
+        long taskId2 = addTaskResponseHandler.getTaskId();
+        
+        EventKey key2 = new TaskEventKey(TaskCompletedEvent.class, taskId2 );           
+        BlockingEventResponseHandler handler2 = new BlockingEventResponseHandler(); 
+        client.registerForEvent( key2, true, handler2 );
+        
+        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(2, tasks.size());
+        
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );
+        
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId2, users.get( "bobba" ).getId(), responseHandler );  
+
+        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
+        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
+        tasks = taskSummaryResponseHandler.getResults(); 
+        assertEquals(1, tasks.size());
+        
+        Payload payload = handler.getPayload();
+        TaskCompletedEvent event = ( TaskCompletedEvent ) payload.get();
+        assertNotNull( event );
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        task = getTaskResponseHandler.getTask();
+        assertEquals( Status.Completed , task.getTaskData().getStatus() );
+        
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.complete( taskId2, users.get( "bobba" ).getId(), null, responseHandler );
+        
+        payload = handler.getPayload();
+        event = ( TaskCompletedEvent ) payload.get();
+        assertNotNull( event );
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler2 = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId2, getTaskResponseHandler2 );
+        task2 = getTaskResponseHandler2.getTask();
+        assertEquals( Status.Completed , task2.getTaskData().getStatus() );
+    }
+
+	public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskLifeCycleTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,193 +0,0 @@
-package org.drools.task.service;
-
-import java.io.StringReader;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.commons.collections.map.HashedMap;
-import org.drools.SystemEventListenerFactory;
-import org.drools.eventmessaging.EventKey;
-import org.drools.eventmessaging.Payload;
-import org.drools.task.BaseTest;
-import org.drools.task.Status;
-import org.drools.task.Task;
-import org.drools.task.event.TaskCompletedEvent;
-import org.drools.task.event.TaskEventKey;
-import org.drools.task.query.TaskSummary;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingEventResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingTaskSummaryResponseHandler;
-
-public class TaskLifeCycleTest extends BaseTest {
-	
-    MinaTaskServer server;
-    TaskClient client;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        server = new MinaTaskServer( taskService );
-        Thread thread = new Thread( server );
-        thread.start();
-        Thread.sleep( 500 );
-        
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-                                new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-        client.disconnect();
-        server.stop();
-    }    
-    
-    @SuppressWarnings("unchecked")
-	public void testLifeCycle() throws Exception {      
-        Map<String, Object> vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );                
-
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { workItemId = 1 } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba']], }),";                        
-//        str += "descriptions = [ new I18NText( 'en-UK', 'This is my description')], ";
-//        str += "subjects = [ new I18NText( 'en-UK', 'This is my subject')], ";
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId );           
-        BlockingEventResponseHandler handler = new BlockingEventResponseHandler(); 
-        client.registerForEvent( key, true, handler );
-        
-        BlockingTaskSummaryResponseHandler taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        List<TaskSummary> tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(1, tasks.size());
-        assertEquals(Status.Reserved, tasks.get(0).getStatus());
-        
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "bobba" ).getId(), responseHandler );  
-
-        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(1, tasks.size());
-        assertEquals(Status.InProgress, tasks.get(0).getStatus());
-        
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );
-        
-        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(0, tasks.size());
-        
-        Payload payload = handler.getPayload();
-        TaskCompletedEvent event = ( TaskCompletedEvent ) payload.get();
-        assertNotNull( event );
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Completed , task1.getTaskData().getStatus() );         
-    }
-  
-    @SuppressWarnings("unchecked")
-	public void testLifeCycleMultipleTasks() throws Exception {      
-        Map<String, Object> vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );                
-
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { workItemId = 1 } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba']], }),";                        
-        str += "descriptions = [ new I18NText( 'en-UK', 'This is my description')], ";
-        str += "subjects = [ new I18NText( 'en-UK', 'This is my subject')], ";
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        EventKey key = new TaskEventKey(TaskCompletedEvent.class, taskId );           
-        BlockingEventResponseHandler handler = new BlockingEventResponseHandler(); 
-        client.registerForEvent( key, true, handler );
-        
-        BlockingTaskSummaryResponseHandler taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        List<TaskSummary> tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(1, tasks.size());
-        assertEquals(Status.Reserved, tasks.get(0).getStatus());
-        
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "bobba" ).getId(), responseHandler );  
-
-        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(1, tasks.size());
-        assertEquals(Status.InProgress, tasks.get(0).getStatus());
-        
-        BlockingAddTaskResponseHandler addTaskResponseHandler2 = new BlockingAddTaskResponseHandler();
-        Task task2 = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task2, null, addTaskResponseHandler2 );
-        long taskId2 = addTaskResponseHandler.getTaskId();
-        
-        EventKey key2 = new TaskEventKey(TaskCompletedEvent.class, taskId2 );           
-        BlockingEventResponseHandler handler2 = new BlockingEventResponseHandler(); 
-        client.registerForEvent( key2, true, handler2 );
-        
-        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(2, tasks.size());
-        
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );
-        
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId2, users.get( "bobba" ).getId(), responseHandler );  
-
-        taskSummaryResponseHandler = new BlockingTaskSummaryResponseHandler();
-        client.getTasksAssignedAsPotentialOwner(users.get( "bobba" ).getId(), "en-UK", taskSummaryResponseHandler);
-        tasks = taskSummaryResponseHandler.getResults(); 
-        assertEquals(1, tasks.size());
-        
-        Payload payload = handler.getPayload();
-        TaskCompletedEvent event = ( TaskCompletedEvent ) payload.get();
-        assertNotNull( event );
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        task = getTaskResponseHandler.getTask();
-        assertEquals( Status.Completed , task.getTaskData().getStatus() );
-        
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete( taskId2, users.get( "bobba" ).getId(), null, responseHandler );
-        
-        payload = handler.getPayload();
-        event = ( TaskCompletedEvent ) payload.get();
-        assertNotNull( event );
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler2 = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId2, getTaskResponseHandler2 );
-        task2 = getTaskResponseHandler2.getTask();
-        assertEquals( Status.Completed , task2.getTaskData().getStatus() );
-    }
-    
-}

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceBaseTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -15,17 +15,8 @@
 
 public abstract class TaskServiceBaseTest extends BaseTest {
 
-    protected TaskClient client;
+    private TaskClient client;
 
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-    }
-
     @SuppressWarnings("unchecked")
     public void testTasksOwnedQueryWithI18N() throws Exception {
         Map<String, Object>  vars = new HashedMap();     
@@ -33,7 +24,7 @@
         vars.put( "groups", groups );        
         
         //Reader reader;
-        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "QueryData_TasksOwned.mvel" ) );
+        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryData_TasksOwned.mvel" ) );
         List<Task> tasks = (List<Task>) eval( reader,
                                               vars );
         for ( Task task : tasks ) {
@@ -42,7 +33,7 @@
         }
 
         // Test UK I18N  
-        reader = new InputStreamReader( getClass().getResourceAsStream( "QueryResults_TasksOwnedInEnglish.mvel" ) );
+        reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryResults_TasksOwnedInEnglish.mvel" ) );
         Map<String, List<TaskSummary>> expected = (Map<String, List<TaskSummary>>) eval( reader,
                                                                                          vars );
 
@@ -77,7 +68,7 @@
                                             actual ) );
 
         // Test DK I18N 
-        reader = new InputStreamReader( getClass().getResourceAsStream( "QueryResults_TasksOwnedInGerman.mvel" ) );
+        reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryResults_TasksOwnedInGerman.mvel" ) );
         expected = (Map<String, List<TaskSummary>>) eval( reader,
                                                           vars );
 
@@ -119,14 +110,14 @@
         vars.put( "groups",
                   groups );
 
-        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "QueryData_TasksOwned.mvel" ) );
+        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryData_TasksOwned.mvel" ) );
         List<Task> tasks = (List<Task>) eval( reader,
                                               vars );
         for ( Task task : tasks ) {
             taskSession.addTask( task, null );
         }
 
-        reader = new InputStreamReader( getClass().getResourceAsStream( "QueryResults_PeopleAssignmentQuerries.mvel" ) );
+        reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryResults_PeopleAssignmentQuerries.mvel" ) );
         Map<String, List<TaskSummary>> expected = (Map<String, List<TaskSummary>>) eval( reader,
                                                                                          vars );
 
@@ -179,7 +170,15 @@
                                             actual ) );
     }
 
-    public static class BlockingAllOpenTasksForUseResponseHandler
+    public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+
+	public static class BlockingAllOpenTasksForUseResponseHandler
         implements
         TaskSummaryResponseHandler {
         private volatile List<TaskSummary> results;

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceCommentsAndAttachmentsBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceCommentsAndAttachmentsBaseTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceCommentsAndAttachmentsBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -24,7 +24,7 @@
 
 public abstract class TaskServiceCommentsAndAttachmentsBaseTest extends BaseTest {
 
-    protected TaskClient client;
+    private TaskClient client;
 
     @Override
     protected void setUp() throws Exception {
@@ -36,7 +36,15 @@
         client.disconnect();
     }
 
-    public void testAddRemoveComment() {
+    public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+
+	public void testAddRemoveComment() {
         Map  vars = new HashedMap();     
         vars.put( "users", users );
         vars.put( "groups", groups );        

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,195 @@
+package org.drools.task.service;
+
+import java.io.InputStreamReader;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+import javax.mail.internet.MimeMessage.RecipientType;
+
+import org.apache.commons.collections.map.HashedMap;
+import org.drools.process.instance.impl.DefaultWorkItemManager;
+import org.drools.runtime.process.WorkItemManager;
+import org.drools.task.BaseTest;
+import org.drools.task.Content;
+import org.drools.task.MockUserInfo;
+import org.drools.task.OrganizationalEntity;
+import org.drools.task.Status;
+import org.drools.task.Task;
+import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingSetContentResponseHandler;
+import org.subethamail.wiser.Wiser;
+import org.subethamail.wiser.WiserMessage;
+
+public abstract class TaskServiceDeadlinesBaseTest extends BaseTest {
+
+    private TaskClient client;
+    private Properties conf;
+    private Wiser wiser;
+
+    public void testDelayedEmailNotificationOnDeadline() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+        vars.put( "now", new Date() ); 
+        
+        DefaultEscalatedDeadlineHandler notificationHandler = new DefaultEscalatedDeadlineHandler( getConf() );
+        WorkItemManager manager = new DefaultWorkItemManager( null );
+        notificationHandler.setManager( manager );
+        
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put( users.get("tony"), "tony at domain.com" );
+        userInfo.getEmails().put( users.get("darth"), "darth at domain.com" );
+        
+        userInfo.getLanguages().put(  users.get("tony"), "en-UK" );
+        userInfo.getLanguages().put(  users.get("darth"), "en-UK" );
+        notificationHandler.setUserInfo( userInfo );    
+        
+        taskService.setEscalatedDeadlineHandler( notificationHandler );
+        
+        String string = toString( new InputStreamReader( getClass().getResourceAsStream( "../DeadlineWithNotification.mvel" ) ) );
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( string ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        long taskId = addTaskResponseHandler.getTaskId();    
+                                        
+        Content content = new Content();
+        content.setContent( "['subject' : 'My Subject', 'body' : 'My Body']".getBytes() );
+        BlockingSetContentResponseHandler setContentResponseHandler  = new BlockingSetContentResponseHandler();
+        client.setDocumentContent( taskId, content, setContentResponseHandler );
+        long contentId = setContentResponseHandler.getContentId();
+        BlockingGetContentResponseHandler  getResponseHandler = new BlockingGetContentResponseHandler();
+        client.getContent( contentId, getResponseHandler );
+        content = getResponseHandler.getContent();
+        assertEquals( "['subject' : 'My Subject', 'body' : 'My Body']", new String( content.getContent() ) );
+        
+        // emails should not be set yet
+        assertEquals(0, getWiser().getMessages().size() );             
+        Thread.sleep( 100 );
+        
+        // nor yet
+        assertEquals(0, getWiser().getMessages().size() );     
+        
+        long time = 0;
+        while ( getWiser().getMessages().size() != 2 && time < 15000 ) {
+            Thread.sleep( 500 );
+            time += 500;
+        }
+        
+        // 1 email with two recipients should now exist
+        assertEquals(2, getWiser().getMessages().size() );        
+        
+        List<String> list = new ArrayList<String>(2);
+        list.add( getWiser().getMessages().get( 0 ).getEnvelopeReceiver() );
+        list.add( getWiser().getMessages().get( 1 ).getEnvelopeReceiver() );
+        
+        assertTrue( list.contains("tony at domain.com"));
+        assertTrue( list.contains("darth at domain.com"));
+        
+        
+        MimeMessage msg = (( WiserMessage  ) getWiser().getMessages().get( 0 )).getMimeMessage();
+        assertEquals( "My Body", msg.getContent() );
+        assertEquals( "My Subject", msg.getSubject() );
+        assertEquals( "from at domain.com", ((InternetAddress)msg.getFrom()[0]).getAddress() );
+        assertEquals( "replyTo at domain.com", ((InternetAddress)msg.getReplyTo()[0]).getAddress() );
+        assertEquals( "tony at domain.com", ((InternetAddress)msg.getRecipients( RecipientType.TO )[0]).getAddress() );
+        assertEquals( "darth at domain.com", ((InternetAddress)msg.getRecipients( RecipientType.TO )[1]).getAddress() );        
+    }
+    
+    public void testDelayedReassignmentOnDeadline() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+        vars.put( "now", new Date() ); 
+        
+        DefaultEscalatedDeadlineHandler notificationHandler = new DefaultEscalatedDeadlineHandler(getConf());
+        WorkItemManager manager = new DefaultWorkItemManager( null );
+        notificationHandler.setManager( manager );
+        
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put( users.get("tony"), "tony at domain.com" );
+        userInfo.getEmails().put( users.get("luke"), "luke at domain.com" );
+        userInfo.getEmails().put( users.get("bobba"), "luke at domain.com" );
+        userInfo.getEmails().put( users.get("jabba"), "luke at domain.com" );
+        
+        userInfo.getLanguages().put(  users.get("tony"), "en-UK" );
+        userInfo.getLanguages().put(  users.get("luke"), "en-UK" );
+        userInfo.getLanguages().put(  users.get("bobba"), "en-UK" );
+        userInfo.getLanguages().put(  users.get("jabba"), "en-UK" );
+        notificationHandler.setUserInfo( userInfo );    
+        
+        taskService.setEscalatedDeadlineHandler( notificationHandler );
+        
+        String string = toString( new InputStreamReader( getClass().getResourceAsStream( "../DeadlineWithReassignment.mvel" ) ) );
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( string ), vars );               
+        client.addTask( task, null, addTaskResponseHandler );
+        long taskId = addTaskResponseHandler.getTaskId();    
+        
+        // Shouldn't have re-assigned yet
+        Thread.sleep( 1000 );
+        BlockingGetTaskResponseHandler getTaskHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskHandler );
+        task = getTaskHandler.getTask();
+        List<OrganizationalEntity> potentialOwners = task.getPeopleAssignments().getPotentialOwners();
+        List<String> ids = new ArrayList<String>(potentialOwners.size());
+        for ( OrganizationalEntity entity : potentialOwners ) {
+            ids.add( entity.getId() );
+        }
+        assertTrue( ids.contains( users.get( "tony" ).getId() ));
+        assertTrue( ids.contains( users.get( "luke" ).getId() ));        
+        
+        // should have re-assigned by now
+        long time = 0;
+        while ( getWiser().getMessages().size() != 2 && time < 15000 ) {
+            Thread.sleep( 500 );
+            time += 500;
+        }
+        
+        getTaskHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskHandler );
+        task = getTaskHandler.getTask();
+        assertEquals( Status.Ready, task.getTaskData().getStatus()  );
+        potentialOwners = task.getPeopleAssignments().getPotentialOwners();
+        System.out.println( potentialOwners );
+        ids = new ArrayList<String>(potentialOwners.size());
+        for ( OrganizationalEntity entity : potentialOwners ) {
+            ids.add( entity.getId() );
+        }
+        assertTrue( ids.contains( users.get( "bobba" ).getId() ));
+        assertTrue( ids.contains( users.get( "jabba" ).getId() ));                  
+    }
+
+	public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+
+	public void setConf(Properties conf) {
+		this.conf = conf;
+	}
+
+	public Properties getConf() {
+		return conf;
+	}
+
+	public void setWiser(Wiser wiser) {
+		this.wiser = wiser;
+	}
+
+	public Wiser getWiser() {
+		return wiser;
+	}
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceDeadlinesTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,211 +0,0 @@
-package org.drools.task.service;
-
-import java.io.InputStreamReader;
-import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-
-import javax.mail.internet.InternetAddress;
-import javax.mail.internet.MimeMessage;
-import javax.mail.internet.MimeMessage.RecipientType;
-
-import org.apache.commons.collections.map.HashedMap;
-import org.drools.SystemEventListenerFactory;
-import org.drools.process.instance.impl.DefaultWorkItemManager;
-import org.drools.runtime.process.WorkItemManager;
-import org.drools.task.BaseTest;
-import org.drools.task.Content;
-import org.drools.task.MockUserInfo;
-import org.drools.task.OrganizationalEntity;
-import org.drools.task.Status;
-import org.drools.task.Task;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingSetContentResponseHandler;
-import org.subethamail.wiser.Wiser;
-import org.subethamail.wiser.WiserMessage;
-
-public class TaskServiceDeadlinesTest extends BaseTest {
-    MinaTaskServer server;
-    TaskClient client;
-    Properties conf;
-    
-    Wiser wiser;
-
-    @Override
-    protected void setUp() throws Exception {        
-        super.setUp();
-        
-        conf = new Properties();
-        conf.setProperty( "mail.smtp.host", "localhost" );
-        conf.setProperty( "mail.smtp.port", "2345" );
-        conf.setProperty( "from", "from at domain.com" );
-        conf.setProperty( "replyTo", "replyTo at domain.com" );
-        conf.setProperty( "defaultLanguage", "en-UK" );
-        
-        server = new MinaTaskServer( taskService );
-        Thread thread = new Thread( server );
-        thread.start();
-        Thread.sleep( 500 );
-
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-                                     new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-        
-        wiser = new Wiser();
-        wiser.setHostname( conf.getProperty( "mail.smtp.host" ) );
-        wiser.setPort( Integer.parseInt( conf.getProperty( "mail.smtp.port" ) ) );        
-        wiser.start();
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-        client.disconnect();
-        server.stop();
-        
-        wiser.stop();
-    }
-    
-    public void testDelayedEmailNotificationOnDeadline() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );
-        vars.put( "now", new Date() ); 
-        
-        DefaultEscalatedDeadlineHandler notificationHandler = new DefaultEscalatedDeadlineHandler( conf );
-        WorkItemManager manager = new DefaultWorkItemManager( null );
-        notificationHandler.setManager( manager );
-        
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get("tony"), "tony at domain.com" );
-        userInfo.getEmails().put( users.get("darth"), "darth at domain.com" );
-        
-        userInfo.getLanguages().put(  users.get("tony"), "en-UK" );
-        userInfo.getLanguages().put(  users.get("darth"), "en-UK" );
-        notificationHandler.setUserInfo( userInfo );    
-        
-        taskService.setEscalatedDeadlineHandler( notificationHandler );
-        
-        String string = toString( new InputStreamReader( getClass().getResourceAsStream( "DeadlineWithNotification.mvel" ) ) );
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( string ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        long taskId = addTaskResponseHandler.getTaskId();    
-                                        
-        Content content = new Content();
-        content.setContent( "['subject' : 'My Subject', 'body' : 'My Body']".getBytes() );
-        BlockingSetContentResponseHandler setContentResponseHandler  = new BlockingSetContentResponseHandler();
-        client.setDocumentContent( taskId, content, setContentResponseHandler );
-        long contentId = setContentResponseHandler.getContentId();
-        BlockingGetContentResponseHandler  getResponseHandler = new BlockingGetContentResponseHandler();
-        client.getContent( contentId, getResponseHandler );
-        content = getResponseHandler.getContent();
-        assertEquals( "['subject' : 'My Subject', 'body' : 'My Body']", new String( content.getContent() ) );
-        
-        // emails should not be set yet
-        assertEquals(0, wiser.getMessages().size() );             
-        Thread.sleep( 100 );
-        
-        // nor yet
-        assertEquals(0, wiser.getMessages().size() );     
-        
-        long time = 0;
-        while ( wiser.getMessages().size() != 2 && time < 15000 ) {
-            Thread.sleep( 500 );
-            time += 500;
-        }
-        
-        
-        // 1 email with two recipients should now exist
-        assertEquals(2, wiser.getMessages().size() );        
-        
-        List<String> list = new ArrayList<String>(2);
-        list.add( wiser.getMessages().get( 0 ).getEnvelopeReceiver() );
-        list.add( wiser.getMessages().get( 1 ).getEnvelopeReceiver() );
-        
-        assertTrue( list.contains("tony at domain.com"));
-        assertTrue( list.contains("darth at domain.com"));
-        
-        
-        MimeMessage msg = (( WiserMessage  ) wiser.getMessages().get( 0 )).getMimeMessage();
-        assertEquals( "My Body", msg.getContent() );
-        assertEquals( "My Subject", msg.getSubject() );
-        assertEquals( "from at domain.com", ((InternetAddress)msg.getFrom()[0]).getAddress() );
-        assertEquals( "replyTo at domain.com", ((InternetAddress)msg.getReplyTo()[0]).getAddress() );
-        assertEquals( "tony at domain.com", ((InternetAddress)msg.getRecipients( RecipientType.TO )[0]).getAddress() );
-        assertEquals( "darth at domain.com", ((InternetAddress)msg.getRecipients( RecipientType.TO )[1]).getAddress() );        
-    }
-    
-    public void testDelayedReassignmentOnDeadline() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );
-        vars.put( "now", new Date() ); 
-        
-        DefaultEscalatedDeadlineHandler notificationHandler = new DefaultEscalatedDeadlineHandler(conf);
-        WorkItemManager manager = new DefaultWorkItemManager( null );
-        notificationHandler.setManager( manager );
-        
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get("tony"), "tony at domain.com" );
-        userInfo.getEmails().put( users.get("luke"), "luke at domain.com" );
-        userInfo.getEmails().put( users.get("bobba"), "luke at domain.com" );
-        userInfo.getEmails().put( users.get("jabba"), "luke at domain.com" );
-        
-        userInfo.getLanguages().put(  users.get("tony"), "en-UK" );
-        userInfo.getLanguages().put(  users.get("luke"), "en-UK" );
-        userInfo.getLanguages().put(  users.get("bobba"), "en-UK" );
-        userInfo.getLanguages().put(  users.get("jabba"), "en-UK" );
-        notificationHandler.setUserInfo( userInfo );    
-        
-        taskService.setEscalatedDeadlineHandler( notificationHandler );
-        
-        String string = toString( new InputStreamReader( getClass().getResourceAsStream( "DeadlineWithReassignment.mvel" ) ) );
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( string ), vars );               
-        client.addTask( task, null, addTaskResponseHandler );
-        long taskId = addTaskResponseHandler.getTaskId();    
-        
-        // Shouldn't have re-assigned yet
-        Thread.sleep( 1000 );
-        BlockingGetTaskResponseHandler getTaskHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskHandler );
-        task = getTaskHandler.getTask();
-        List<OrganizationalEntity> potentialOwners = task.getPeopleAssignments().getPotentialOwners();
-        List<String> ids = new ArrayList<String>(potentialOwners.size());
-        for ( OrganizationalEntity entity : potentialOwners ) {
-            ids.add( entity.getId() );
-        }
-        assertTrue( ids.contains( users.get( "tony" ).getId() ));
-        assertTrue( ids.contains( users.get( "luke" ).getId() ));        
-        
-        // should have re-assigned by now
-        long time = 0;
-        while ( wiser.getMessages().size() != 2 && time < 15000 ) {
-            Thread.sleep( 500 );
-            time += 500;
-        }
-        
-        getTaskHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskHandler );
-        task = getTaskHandler.getTask();
-        assertEquals( Status.Ready, task.getTaskData().getStatus()  );
-        potentialOwners = task.getPeopleAssignments().getPotentialOwners();
-        System.out.println( potentialOwners );
-        ids = new ArrayList<String>(potentialOwners.size());
-        for ( OrganizationalEntity entity : potentialOwners ) {
-            ids.add( entity.getId() );
-        }
-        assertTrue( ids.contains( users.get( "bobba" ).getId() ));
-        assertTrue( ids.contains( users.get( "jabba" ).getId() ));                  
-    }
-}

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,205 @@
+package org.drools.task.service;
+
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+
+import org.apache.commons.collections.map.HashedMap;
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.BaseTest;
+import org.drools.task.Deadline;
+import org.drools.task.Task;
+import org.drools.task.service.TaskServiceEscalationBaseTest.MockEscalatedDeadlineHandler.Item;
+import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
+
+public abstract class TaskServiceEscalationBaseTest extends BaseTest {
+
+	private TaskClient client;
+
+    public void testDummy() {
+        assertTrue( true );
+    }
+
+    public void FIXME_testUnescalatedDeadlines() throws Exception {
+        Map vars = new HashedMap();
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+
+        MockEscalatedDeadlineHandler handler = new MockEscalatedDeadlineHandler();
+        taskService.setEscalatedDeadlineHandler( handler );  
+        
+        //Reader reader;
+        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryData_UnescalatedDeadlines.mvel" ) );
+        List<Task> tasks = (List<Task>) eval( reader,
+                                              vars );
+        long now = ((Date)vars.get( "now" )).getTime();
+        
+        for ( Task task : tasks ) {  
+            BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();            
+            client.addTask( task, null, addTaskResponseHandler ); 
+            addTaskResponseHandler.waitTillDone( 3000 );
+        }
+
+        handler.wait( 3, 30000 );
+        
+        assertEquals( 3, handler.list.size() );
+        
+        Item item0 = handler.list.get( 0 );        
+        assertEquals( now + 20000,
+                      item0.getDeadline().getDate().getTime() );
+        
+        Item item1 = handler.list.get( 1 );
+        assertEquals( now + 22000,
+                      item1.getDeadline().getDate().getTime() );
+        
+        Item item2 = handler.list.get( 2 );
+        assertEquals( now + 24000,
+                      item2.getDeadline().getDate().getTime() );        
+    }
+    
+    public void FIXME_testUnescalatedDeadlinesOnStartup() throws Exception {
+        Map vars = new HashedMap();
+        vars.put( "users", users );
+        vars.put( "groups", groups );
+
+        //Reader reader;
+        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryData_UnescalatedDeadlines.mvel" ) );
+        List<Task> tasks = (List<Task>) eval( reader,
+                                              vars );
+        long now = ((Date)vars.get( "now" )).getTime();
+        
+        EntityManager em = emf.createEntityManager();
+        em.getTransaction().begin();
+        for ( Task task : tasks ) {
+            // for this one we put the task in directly;
+            em.persist( task );
+        }
+        em.getTransaction().commit();
+
+        // now create a new service, to see if it initiates from the DB correctly
+        MockEscalatedDeadlineHandler handler = new MockEscalatedDeadlineHandler();
+        TaskService local = new TaskService(emf, SystemEventListenerFactory.getSystemEventListener(), handler);      
+                
+        handler.wait( 3, 30000 );
+        
+        assertEquals( 3, handler.list.size() );
+
+        Item item0 = handler.list.get( 0 );
+        assertEquals( item0.getDeadline().getDate().getTime(),
+                      now + 20000 );
+        
+        Item item1 = handler.list.get( 1 );
+        assertEquals( item1.getDeadline().getDate().getTime(),
+                      now + 22000 );
+        
+        Item item2 = handler.list.get( 2 );
+        assertEquals( item2.getDeadline().getDate().getTime(),
+                      now + 24000 );            
+    }
+
+    public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+
+	public static class MockEscalatedDeadlineHandler
+        implements
+        EscalatedDeadlineHandler {
+
+        List<Item> list = new ArrayList<Item>();
+        
+        TaskService taskService;
+
+        public void executeEscalatedDeadline(Task task,
+                                             Deadline deadline,
+                                             EntityManager em,
+                                             TaskService taskService) {
+            list.add( new Item( task,
+                                deadline,
+                                em,
+                                taskService ) );
+        }
+        
+        public List<Item> getList() {
+            return this.list;
+        }
+
+        public static class Item {
+            Task          task;
+            Deadline      deadline;
+            EntityManager em;
+
+            public Item(Task task,
+                        Deadline deadline,
+                        EntityManager em,
+                        TaskService taskService) {
+                this.deadline = deadline;
+                this.em = em;
+                this.task = task;
+            }
+
+            public Task getTask() {
+                return task;
+            }
+
+            public void setTask(Task task) {
+                this.task = task;
+            }
+
+            public Deadline getDeadline() {
+                return deadline;
+            }
+
+            public void setDeadline(Deadline deadline) {
+                this.deadline = deadline;
+            }
+
+            public EntityManager getEntityManager() {
+                return em;
+            }
+
+            public void setEntityManager(EntityManager em) {
+                this.em = em;
+            }
+
+            public EntityManager getEm() {
+                return em;
+            }
+
+            public void setEm(EntityManager em) {
+                this.em = em;
+            }                        
+        }   
+        
+        public synchronized void wait(int totalSize, int totalWait) {
+            int wait = 0;
+            int size = 0;
+            
+            while ( true ) {
+                synchronized ( list ) {
+                    size = list.size();
+                }
+                
+                if ( size >= totalSize || wait >= totalWait ) {
+                    break;
+                }
+                
+                try {
+                    Thread.sleep( 250 );
+                } catch( Exception e ) {
+                    throw new RuntimeException( "Unable to sleep", e);
+                }
+                wait += 250;
+            }
+        }
+    }
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEscalationTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,223 +0,0 @@
-package org.drools.task.service;
-
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
-import javax.persistence.EntityManager;
-
-import org.apache.commons.collections.map.HashedMap;
-import org.drools.SystemEventListenerFactory;
-import org.drools.task.BaseTest;
-import org.drools.task.Deadline;
-import org.drools.task.Task;
-import org.drools.task.service.TaskServiceEscalationTest.MockEscalatedDeadlineHandler.Item;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
-
-public class TaskServiceEscalationTest extends BaseTest {
-    MinaTaskServer server;
-    TaskClient client;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        server = new MinaTaskServer( taskService );
-        Thread thread = new Thread( server );
-        thread.start();
-        Thread.sleep( 500 );
-
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-                                     new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-        client.disconnect();
-        server.stop();
-    }
-    
-    public void testDummy() {
-        assertTrue( true );
-    }
-
-    public void FIXME_testUnescalatedDeadlines() throws Exception {
-        Map vars = new HashedMap();
-        vars.put( "users",
-                  users );
-        vars.put( "groups",
-                  groups );
-
-        MockEscalatedDeadlineHandler handler = new MockEscalatedDeadlineHandler();
-        taskService.setEscalatedDeadlineHandler( handler );  
-        
-        //Reader reader;
-        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryData_UnescalatedDeadlines.mvel" ) );
-        List<Task> tasks = (List<Task>) eval( reader,
-                                              vars );
-        long now = ((Date)vars.get( "now" )).getTime();
-        
-        for ( Task task : tasks ) {  
-            BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();            
-            client.addTask( task, null, addTaskResponseHandler ); 
-            addTaskResponseHandler.waitTillDone( 3000 );
-        }
-
-        handler.wait( 3, 30000 );
-        
-        assertEquals( 3, handler.list.size() );
-        
-        Item item0 = handler.list.get( 0 );        
-        assertEquals( now + 20000,
-                      item0.getDeadline().getDate().getTime() );
-        
-        Item item1 = handler.list.get( 1 );
-        assertEquals( now + 22000,
-                      item1.getDeadline().getDate().getTime() );
-        
-        Item item2 = handler.list.get( 2 );
-        assertEquals( now + 24000,
-                      item2.getDeadline().getDate().getTime() );        
-    }
-    
-    public void FIXME_testUnescalatedDeadlinesOnStartup() throws Exception {
-        Map vars = new HashedMap();
-        vars.put( "users",
-                  users );
-        vars.put( "groups",
-                  groups );
-
-        //Reader reader;
-        Reader reader = new InputStreamReader( getClass().getResourceAsStream( "../QueryData_UnescalatedDeadlines.mvel" ) );
-        List<Task> tasks = (List<Task>) eval( reader,
-                                              vars );
-        long now = ((Date)vars.get( "now" )).getTime();
-        
-        EntityManager em = emf.createEntityManager();
-        em.getTransaction().begin();
-        for ( Task task : tasks ) {
-            // for this one we put the task in directly;
-            em.persist( task );
-        }
-        em.getTransaction().commit();
-
-        // now create a new service, to see if it initiates from the DB correctly
-        MockEscalatedDeadlineHandler handler = new MockEscalatedDeadlineHandler();
-        TaskService local = new TaskService(emf, SystemEventListenerFactory.getSystemEventListener(), handler);      
-                
-        handler.wait( 3, 30000 );
-        
-        assertEquals( 3, handler.list.size() );
-
-        Item item0 = handler.list.get( 0 );
-        assertEquals( item0.getDeadline().getDate().getTime(),
-                      now + 20000 );
-        
-        Item item1 = handler.list.get( 1 );
-        assertEquals( item1.getDeadline().getDate().getTime(),
-                      now + 22000 );
-        
-        Item item2 = handler.list.get( 2 );
-        assertEquals( item2.getDeadline().getDate().getTime(),
-                      now + 24000 );            
-    }
-
-    public static class MockEscalatedDeadlineHandler
-        implements
-        EscalatedDeadlineHandler {
-
-        List<Item> list = new ArrayList<Item>();
-        
-        TaskService taskService;
-
-        public void executeEscalatedDeadline(Task task,
-                                             Deadline deadline,
-                                             EntityManager em,
-                                             TaskService taskService) {
-            list.add( new Item( task,
-                                deadline,
-                                em,
-                                taskService ) );
-        }
-        
-        public List<Item> getList() {
-            return this.list;
-        }
-
-        public static class Item {
-            Task          task;
-            Deadline      deadline;
-            EntityManager em;
-
-            public Item(Task task,
-                        Deadline deadline,
-                        EntityManager em,
-                        TaskService taskService) {
-                this.deadline = deadline;
-                this.em = em;
-                this.task = task;
-            }
-
-            public Task getTask() {
-                return task;
-            }
-
-            public void setTask(Task task) {
-                this.task = task;
-            }
-
-            public Deadline getDeadline() {
-                return deadline;
-            }
-
-            public void setDeadline(Deadline deadline) {
-                this.deadline = deadline;
-            }
-
-            public EntityManager getEntityManager() {
-                return em;
-            }
-
-            public void setEntityManager(EntityManager em) {
-                this.em = em;
-            }
-
-            public EntityManager getEm() {
-                return em;
-            }
-
-            public void setEm(EntityManager em) {
-                this.em = em;
-            }                        
-        }   
-        
-        public synchronized void wait(int totalSize, int totalWait) {
-            int wait = 0;
-            int size = 0;
-            
-            while ( true ) {
-                synchronized ( list ) {
-                    size = list.size();
-                }
-                
-                if ( size >= totalSize || wait >= totalWait ) {
-                    break;
-                }
-                
-                try {
-                    Thread.sleep( 250 );
-                } catch( Exception e ) {
-                    throw new RuntimeException( "Unable to sleep", e);
-                }
-                wait += 250;
-            }
-        }
-    }
-    
-}

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,68 @@
+package org.drools.task.service;
+
+import java.io.StringReader;
+import java.util.Date;
+import java.util.Map;
+
+import org.apache.commons.collections.map.HashedMap;
+import org.drools.eventmessaging.EventKey;
+import org.drools.eventmessaging.Payload;
+import org.drools.task.BaseTest;
+import org.drools.task.Status;
+import org.drools.task.Task;
+import org.drools.task.event.TaskClaimedEvent;
+import org.drools.task.event.TaskEventKey;
+import org.drools.task.event.TaskUserEvent;
+import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingEventResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
+
+public abstract class TaskServiceEventMessagingBaseTest extends BaseTest {
+
+    private TaskClient client;
+
+    public void testClaimEvent() throws Exception {      
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );                
+
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Ready , task1.getTaskData().getStatus() );         
+        
+        EventKey key = new TaskEventKey(TaskClaimedEvent.class, taskId );           
+        BlockingEventResponseHandler handler = new BlockingEventResponseHandler(); 
+        client.registerForEvent( key, true, handler );
+        Thread.sleep( 3000 );
+        
+        taskSession.taskOperation( Operation.Claim, taskId, users.get( "darth" ).getId(), null, null );          
+        handler.waitTillDone( 5000 );
+        
+        Payload payload = handler.getPayload();
+        TaskUserEvent event = ( TaskUserEvent ) payload.get();
+        assertNotNull( event );        
+    }
+
+	public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+  
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceEventMessagingTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,96 +0,0 @@
-package org.drools.task.service;
-
-import java.io.StringReader;
-import java.util.Date;
-import java.util.Map;
-
-import org.apache.commons.collections.map.HashedMap;
-import org.drools.SystemEventListenerFactory;
-import org.drools.eventmessaging.EventKey;
-import org.drools.eventmessaging.Payload;
-import org.drools.task.BaseTest;
-import org.drools.task.MockUserInfo;
-import org.drools.task.Status;
-import org.drools.task.Task;
-import org.drools.task.event.TaskClaimedEvent;
-import org.drools.task.event.TaskEventKey;
-import org.drools.task.event.TaskUserEvent;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingEventResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
-
-public class TaskServiceEventMessagingTest extends BaseTest {
-    MinaTaskServer server;
-    TaskClient client;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        server = new MinaTaskServer( taskService );
-        Thread thread = new Thread( server );
-        thread.start();
-        Thread.sleep( 500 );
-        
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-                                new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-        
-        MockUserInfo userInfo = new MockUserInfo();
-        userInfo.getEmails().put( users.get( "tony" ),
-                                  "tony at domain.com" );
-        userInfo.getEmails().put( users.get( "steve" ),
-                                  "steve at domain.com" );
-
-        userInfo.getLanguages().put( users.get( "tony" ),
-                                     "en-UK" );
-        userInfo.getLanguages().put( users.get( "steve" ),
-                                     "en-UK" );
-        taskService.setUserinfo( userInfo );
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-        client.disconnect();
-        server.stop();
-    }    
-    
-    public void testClaimEvent() throws Exception {      
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );                
-
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Ready , task1.getTaskData().getStatus() );         
-        
-        EventKey key = new TaskEventKey(TaskClaimedEvent.class, taskId );           
-        BlockingEventResponseHandler handler = new BlockingEventResponseHandler(); 
-        client.registerForEvent( key, true, handler );
-        Thread.sleep( 3000 );
-        
-        taskSession.taskOperation( Operation.Claim, taskId, users.get( "darth" ).getId(), null, null );          
-        handler.waitTillDone( 5000 );
-        
-        Payload payload = handler.getPayload();
-        TaskUserEvent event = ( TaskUserEvent ) payload.get();
-        assertNotNull( event );        
-    }
-  
-}

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleBaseTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleBaseTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleBaseTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,1407 @@
+package org.drools.task.service;
+
+import java.io.StringReader;
+import java.util.Date;
+import java.util.Map;
+
+import org.apache.commons.collections.map.HashedMap;
+import org.drools.task.AccessType;
+import org.drools.task.BaseTest;
+import org.drools.task.Content;
+import org.drools.task.Status;
+import org.drools.task.Task;
+import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
+import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
+
+public abstract class TaskServiceLifeCycleBaseTest extends BaseTest {
+
+    private static final int DEFAULT_WAIT_TIME = 5000;
+
+    private TaskClient client;
+
+    public void testNewTaskWithNoPotentialOwners() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // Task should remain in Created state with no actual owner
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( task1.getTaskData().getStatus(), Status.Created );     
+        assertNull( task1.getTaskData().getActualOwner() );        
+    }
+
+    public void testNewTaskWithSinglePotentialOwner() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // Task should be assigned to the single potential owner and state set to Reserved
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Reserved, task1.getTaskData().getStatus() );     
+        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
+    }
+    
+    public void testNewTaskWithContent() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        ContentData data = new ContentData();
+        data.setAccessType(AccessType.Inline);
+        data.setType("type");
+        data.setContent("content".getBytes());
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, data, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // Task should be assigned to the single potential owner and state set to Reserved
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( AccessType.Inline, task1.getTaskData().getDocumentAccessType() );
+        assertEquals( "type", task1.getTaskData().getDocumentType() );
+        long contentId = task1.getTaskData().getDocumentContentId();
+        assertTrue( contentId != -1 ); 
+
+        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
+        client.getContent(contentId, getContentResponseHandler);
+        Content content = getContentResponseHandler.getContent();
+        assertEquals("content", new String(content.getContent()));
+    }
+    
+    public void testNewTaskWithLargeContent() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        ContentData data = new ContentData();
+        data.setAccessType(AccessType.Inline);
+        data.setType("type");
+        String largeContent = "";
+        for (int i = 0; i < 1000; i++) {
+        	largeContent += i + "xxxxxxxxx";
+        }
+        data.setContent(largeContent.getBytes());
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, data, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // Task should be assigned to the single potential owner and state set to Reserved
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( AccessType.Inline, task1.getTaskData().getDocumentAccessType() );
+        assertEquals( "type", task1.getTaskData().getDocumentType() );
+        long contentId = task1.getTaskData().getDocumentContentId();
+        assertTrue( contentId != -1 ); 
+
+        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
+        client.getContent(contentId, getContentResponseHandler);
+        Content content = getContentResponseHandler.getContent();
+        System.out.println(new String(content.getContent()));
+        assertEquals(largeContent, new String(content.getContent()));
+    }
+    
+    public void testClaimWithMultiplePotentialOwners() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Ready , task1.getTaskData().getStatus() );     
+        
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );        
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
+    }
+
+    public void testStartFromReadyStateWithPotentialOwner() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Ready , task1.getTaskData().getStatus() );     
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );        
+    }
+    
+    public void testStartFromReadyStateWithIncorrectPotentialOwner() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Ready , task1.getTaskData().getStatus() );     
+        
+        // State should not change as user isn't potential owner
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "tony" ).getId(), responseHandler );
+
+        PermissionDeniedException denied = null;
+        try {
+            responseHandler.waitTillDone( DEFAULT_WAIT_TIME );
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );
+        assertNull( task2.getTaskData().getActualOwner() );        
+    }    
+    
+    public void testStartFromReserved() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // Task should be assigned to the single potential owner and state set to Reserved
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Reserved, task1.getTaskData().getStatus());     
+        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
+        
+        // Should change to InProgress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "bobba" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals( Status.InProgress, task2.getTaskData().getStatus() );     
+        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );        
+    }
+    
+    public void testStartFromReservedWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();
+        
+        // Task should be assigned to the single potential owner and state set to Reserved
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Reserved , task1.getTaskData().getStatus());     
+        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
+        
+        // Should change not change
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "tony" ).getId(), responseHandler );
+
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch (PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Reserved, task2.getTaskData().getStatus() );     
+        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );        
+    }
+    
+    public void testStop() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );        
+        
+        // Now Stop
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.stop( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                
+    }    
+    
+    public void testStopWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );        
+        
+        // Should not stop
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.stop( taskId, users.get( "bobba" ).getId(), responseHandler );
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                
+    }   
+    
+    public void testReleaseFromInprogress() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Released
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.release( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );
+        assertNull( task2.getTaskData().getActualOwner() );                  
+    }    
+    
+    public void testReleaseFromReserved() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Released
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.release( taskId, users.get( "darth" ).getId(), responseHandler );  
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );
+        assertNull( task2.getTaskData().getActualOwner() );                  
+    }     
+    
+    public void testReleaseWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is not changed
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.release( taskId, users.get( "bobba" ).getId(), responseHandler );
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() ); 
+    }
+
+    public void testSuspendFromReady() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Check is Ready
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Ready, task1.getTaskData().getStatus() );
+        assertNull( task1.getTaskData().getActualOwner() );  
+        
+        // Check is Suspended
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
+        assertEquals( Status.Ready, task2.getTaskData().getPreviousStatus() );
+        assertNull( task1.getTaskData().getActualOwner() );                  
+    }
+    
+    public void testSuspendFromReserved() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Check is Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );   
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Suspended
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task2.getTaskData().getPreviousStatus() );
+        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );          
+    }    
+    
+    public void testSuspendFromReservedWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Check is Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is not changed
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.suspend( taskId, users.get( "bobba" ).getId(), responseHandler );
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );      
+    }    
+    
+    public void testResumeFromReady() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Check is Ready
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Ready, task1.getTaskData().getStatus() );
+        assertNull( task1.getTaskData().getActualOwner() );  
+        
+        // Check is Suspended
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
+        assertEquals( Status.Ready, task2.getTaskData().getPreviousStatus() );
+        assertNull( task1.getTaskData().getActualOwner() );    
+        
+        // Check is Resumed
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.resume( taskId, users.get( "darth" ).getId(), responseHandler );   
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task3 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Ready, task3.getTaskData().getStatus() );
+        assertEquals( Status.Suspended, task3.getTaskData().getPreviousStatus() );
+        assertNull( task3.getTaskData().getActualOwner() );         
+    }
+    
+    public void testResumeFromReserved() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Check is Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is suspended
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );        
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task2.getTaskData().getPreviousStatus() );
+        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() ); 
+        
+        // Check is Resumed
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.resume( taskId, users.get( "darth" ).getId(), responseHandler ); 
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task3 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task3.getTaskData().getStatus() );
+        assertEquals( Status.Suspended, task3.getTaskData().getPreviousStatus() );
+        assertEquals( users.get( "darth" ), task3.getTaskData().getActualOwner() );           
+    }    
+    
+    public void testResumeFromReservedWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Check is Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check not changed
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.suspend( taskId, users.get( "bobba" ).getId(), responseHandler );
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );      
+    }     
+          
+    public void testSkipFromReady() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { skipable = true} ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ] }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();                     
+        
+        // Check is Complete
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.skip( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Obsolete, task1.getTaskData().getStatus() );
+        assertNull(  task1.getTaskData().getActualOwner() );                  
+    }    
+    
+    public void testSkipFromReserved() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { skipable = true} ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ] }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready 
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        // Check is Complete
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.skip( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Obsolete, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );                  
+    }     
+    
+    public void testDelegateFromReady() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );        
+        long taskId = addTaskResponseHandler.getTaskId();                     
+        
+        // Check is Delegated
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.delegate( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );        
+        Task task2 = getTaskResponseHandler.getTask();
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
+        assertEquals( users.get( "tony" ), task2.getTaskData().getActualOwner() );
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
+    }     
+    
+    public void testDelegateFromReserved() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Claim and Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Delegated
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.delegate( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );        
+        Task task2 = getTaskResponseHandler.getTask();
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
+        assertEquals( users.get( "tony" ), task2.getTaskData().getActualOwner() );
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
+    }     
+    
+    public void testDelegateFromReservedWithIncorrectUser() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Claim and Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check was not delegated
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.delegate( taskId, users.get( "bobba" ).getId(), users.get( "tony" ).getId(), responseHandler );    
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );        
+        Task task2 = getTaskResponseHandler.getTask();
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
+        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
+        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );             
+    }  
+    
+    public void testForwardFromReady() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();                     
+        
+        // Check is Forwarded
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.forward( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );        
+        Task task2 = getTaskResponseHandler.getTask();
+        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
+        assertNull( task2.getTaskData().getActualOwner() );
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
+    }  
+    
+    public void testForwardFromReserved() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Claim and Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Delegated
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.forward( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );        
+        Task task2 = getTaskResponseHandler.getTask();
+        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
+        assertNull( task2.getTaskData().getActualOwner() );
+        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
+    }     
+    
+    public void testForwardFromReservedWithIncorrectUser() throws Exception {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Claim and Reserved
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check was not delegated
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.forward( taskId, users.get( "bobba" ).getId(), users.get( "tony" ).getId(), responseHandler );    
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );        
+        Task task2 = getTaskResponseHandler.getTask();
+        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
+        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
+        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );             
+    }      
+    
+    public void testComplete() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Complete
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.complete( taskId, users.get( "darth" ).getId(), null, responseHandler ); 
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Completed, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
+    }
+        
+    public void testCompleteWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );        
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Should not complete as wrong user
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );  
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
+    }    
+
+    public void testCompleteWithContent() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        ContentData data = new ContentData();
+        data.setAccessType(AccessType.Inline);
+        data.setType("type");
+        data.setContent("content".getBytes());
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.complete( taskId, users.get( "darth" ).getId(), data, responseHandler ); 
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals( AccessType.Inline, task2.getTaskData().getOutputAccessType() );
+        assertEquals( "type", task2.getTaskData().getOutputType() );
+        long contentId = task2.getTaskData().getOutputContentId();
+        assertTrue( contentId != -1 ); 
+        
+        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
+        client.getContent(contentId, getContentResponseHandler);
+        Content content = getContentResponseHandler.getContent();
+        assertEquals("content", new String(content.getContent()));
+    }
+        
+    public void testFail() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Check is Failed
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.fail( taskId, users.get( "darth" ).getId(), null, responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.Failed, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
+    }
+    
+    public void testFailWithIncorrectUser() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );      
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        // Should not fail as wrong user
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.fail( taskId, users.get( "bobba" ).getId(), null, responseHandler );
+        PermissionDeniedException denied = null;
+        try{
+            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        } catch(PermissionDeniedException e) {
+            denied = e;
+        }
+        assertNotNull("Should get permissed denied exception", denied);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
+    }    
+
+    public void testFailWithContent() {
+        Map  vars = new HashedMap();     
+        vars.put( "users", users );
+        vars.put( "groups", groups );        
+        vars.put( "now", new Date() );
+        
+        // One potential owner, should go straight to state Reserved
+        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
+        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
+        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
+            
+        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
+        Task task = ( Task )  eval( new StringReader( str ), vars );
+        client.addTask( task, null, addTaskResponseHandler );
+        
+        long taskId = addTaskResponseHandler.getTaskId();             
+        
+        // Go straight from Ready to Inprogress
+        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
+        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task1 = getTaskResponseHandler.getTask();
+        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
+        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
+        
+        FaultData data = new FaultData();
+        data.setAccessType(AccessType.Inline);
+        data.setType("type");
+        data.setFaultName("faultName");
+        data.setContent("content".getBytes());
+        responseHandler = new BlockingTaskOperationResponseHandler();
+        client.fail( taskId, users.get( "darth" ).getId(), data, responseHandler );
+        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
+        
+        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
+        client.getTask( taskId, getTaskResponseHandler );
+        Task task2 = getTaskResponseHandler.getTask();
+        assertEquals( Status.Failed, task2.getTaskData().getStatus() );
+        assertEquals( AccessType.Inline, task2.getTaskData().getFaultAccessType() );
+        assertEquals( "type", task2.getTaskData().getFaultType() );
+        assertEquals( "faultName", task2.getTaskData().getFaultName() );
+        long contentId = task2.getTaskData().getFaultContentId();
+        assertTrue( contentId != -1 ); 
+        
+        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
+        client.getContent(contentId, getContentResponseHandler);
+        Content content = getContentResponseHandler.getContent();
+        assertEquals("content", new String(content.getContent()));
+    }
+
+	public void setClient(TaskClient client) {
+		this.client = client;
+	}
+
+	public TaskClient getClient() {
+		return client;
+	}
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleBaseTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Deleted: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/TaskServiceLifeCycleTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -1,1421 +0,0 @@
-package org.drools.task.service;
-
-import java.io.StringReader;
-import java.util.Date;
-import java.util.Map;
-
-import org.apache.commons.collections.map.HashedMap;
-import org.drools.SystemEventListenerFactory;
-import org.drools.task.AccessType;
-import org.drools.task.BaseTest;
-import org.drools.task.Content;
-import org.drools.task.Status;
-import org.drools.task.Task;
-import org.drools.task.service.mina.MinaTaskClientConnector;
-import org.drools.task.service.mina.MinaTaskServer;
-import org.drools.task.service.mina.TaskMinaClientHandler;
-import org.drools.task.service.responsehandlers.BlockingAddTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetContentResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingGetTaskResponseHandler;
-import org.drools.task.service.responsehandlers.BlockingTaskOperationResponseHandler;
-
-public class TaskServiceLifeCycleTest extends BaseTest {
-    MinaTaskServer server;
-    TaskClient client;
-    private static final int DEFAULT_WAIT_TIME = 5000;
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        server = new MinaTaskServer( taskService );
-        Thread thread = new Thread( server );
-        thread.start();
-        Thread.sleep( 500 );
-
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-                                     new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
-    }
-
-    protected void tearDown() throws Exception {
-        super.tearDown();
-        client.disconnect();
-        server.stop();
-    }
-    
-    public void testNewTaskWithNoPotentialOwners() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // Task should remain in Created state with no actual owner
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( task1.getTaskData().getStatus(), Status.Created );     
-        assertNull( task1.getTaskData().getActualOwner() );        
-    }
-
-    public void testNewTaskWithSinglePotentialOwner() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // Task should be assigned to the single potential owner and state set to Reserved
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Reserved, task1.getTaskData().getStatus() );     
-        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
-    }
-    
-    public void testNewTaskWithContent() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        ContentData data = new ContentData();
-        data.setAccessType(AccessType.Inline);
-        data.setType("type");
-        data.setContent("content".getBytes());
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, data, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // Task should be assigned to the single potential owner and state set to Reserved
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( AccessType.Inline, task1.getTaskData().getDocumentAccessType() );
-        assertEquals( "type", task1.getTaskData().getDocumentType() );
-        long contentId = task1.getTaskData().getDocumentContentId();
-        assertTrue( contentId != -1 ); 
-
-        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
-        client.getContent(contentId, getContentResponseHandler);
-        Content content = getContentResponseHandler.getContent();
-        assertEquals("content", new String(content.getContent()));
-    }
-    
-    public void testNewTaskWithLargeContent() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        ContentData data = new ContentData();
-        data.setAccessType(AccessType.Inline);
-        data.setType("type");
-        String largeContent = "";
-        for (int i = 0; i < 1000; i++) {
-        	largeContent += i + "xxxxxxxxx";
-        }
-        data.setContent(largeContent.getBytes());
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, data, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // Task should be assigned to the single potential owner and state set to Reserved
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( AccessType.Inline, task1.getTaskData().getDocumentAccessType() );
-        assertEquals( "type", task1.getTaskData().getDocumentType() );
-        long contentId = task1.getTaskData().getDocumentContentId();
-        assertTrue( contentId != -1 ); 
-
-        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
-        client.getContent(contentId, getContentResponseHandler);
-        Content content = getContentResponseHandler.getContent();
-        System.out.println(new String(content.getContent()));
-        assertEquals(largeContent, new String(content.getContent()));
-    }
-    
-    public void testClaimWithMultiplePotentialOwners() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Ready , task1.getTaskData().getStatus() );     
-        
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );        
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
-    }
-
-    public void testStartFromReadyStateWithPotentialOwner() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Ready , task1.getTaskData().getStatus() );     
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );        
-    }
-    
-    public void testStartFromReadyStateWithIncorrectPotentialOwner() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // A Task with multiple potential owners moves to "Ready" state until someone claims it.
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Ready , task1.getTaskData().getStatus() );     
-        
-        // State should not change as user isn't potential owner
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "tony" ).getId(), responseHandler );
-
-        PermissionDeniedException denied = null;
-        try {
-            responseHandler.waitTillDone( DEFAULT_WAIT_TIME );
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );
-        assertNull( task2.getTaskData().getActualOwner() );        
-    }    
-    
-    public void testStartFromReserved() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // Task should be assigned to the single potential owner and state set to Reserved
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Reserved, task1.getTaskData().getStatus());     
-        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
-        
-        // Should change to InProgress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "bobba" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals( Status.InProgress, task2.getTaskData().getStatus() );     
-        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );        
-    }
-    
-    public void testStartFromReservedWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();
-        
-        // Task should be assigned to the single potential owner and state set to Reserved
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Reserved , task1.getTaskData().getStatus());     
-        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );
-        
-        // Should change not change
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "tony" ).getId(), responseHandler );
-
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch (PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler(); 
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Reserved, task2.getTaskData().getStatus() );     
-        assertEquals( users.get( "bobba" ), task1.getTaskData().getActualOwner() );        
-    }
-    
-    public void testStop() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );        
-        
-        // Now Stop
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.stop( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                
-    }    
-    
-    public void testStopWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );        
-        
-        // Should not stop
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.stop( taskId, users.get( "bobba" ).getId(), responseHandler );
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                
-    }   
-    
-    public void testReleaseFromInprogress() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Released
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.release( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );
-        assertNull( task2.getTaskData().getActualOwner() );                  
-    }    
-    
-    public void testReleaseFromReserved() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Released
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.release( taskId, users.get( "darth" ).getId(), responseHandler );  
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );
-        assertNull( task2.getTaskData().getActualOwner() );                  
-    }     
-    
-    public void testReleaseWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is not changed
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.release( taskId, users.get( "bobba" ).getId(), responseHandler );
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() ); 
-    }
-
-    public void testSuspendFromReady() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Check is Ready
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Ready, task1.getTaskData().getStatus() );
-        assertNull( task1.getTaskData().getActualOwner() );  
-        
-        // Check is Suspended
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
-        assertEquals( Status.Ready, task2.getTaskData().getPreviousStatus() );
-        assertNull( task1.getTaskData().getActualOwner() );                  
-    }
-    
-    public void testSuspendFromReserved() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Check is Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );   
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Suspended
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task2.getTaskData().getPreviousStatus() );
-        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );          
-    }    
-    
-    public void testSuspendFromReservedWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Check is Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is not changed
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.suspend( taskId, users.get( "bobba" ).getId(), responseHandler );
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );      
-    }    
-    
-    public void testResumeFromReady() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Check is Ready
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Ready, task1.getTaskData().getStatus() );
-        assertNull( task1.getTaskData().getActualOwner() );  
-        
-        // Check is Suspended
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
-        assertEquals( Status.Ready, task2.getTaskData().getPreviousStatus() );
-        assertNull( task1.getTaskData().getActualOwner() );    
-        
-        // Check is Resumed
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.resume( taskId, users.get( "darth" ).getId(), responseHandler );   
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task3 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Ready, task3.getTaskData().getStatus() );
-        assertEquals( Status.Suspended, task3.getTaskData().getPreviousStatus() );
-        assertNull( task3.getTaskData().getActualOwner() );         
-    }
-    
-    public void testResumeFromReserved() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Check is Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is suspended
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.suspend( taskId, users.get( "darth" ).getId(), responseHandler );        
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task2.getTaskData().getPreviousStatus() );
-        assertEquals(  Status.Suspended, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() ); 
-        
-        // Check is Resumed
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.resume( taskId, users.get( "darth" ).getId(), responseHandler ); 
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task3 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task3.getTaskData().getStatus() );
-        assertEquals( Status.Suspended, task3.getTaskData().getPreviousStatus() );
-        assertEquals( users.get( "darth" ), task3.getTaskData().getActualOwner() );           
-    }    
-    
-    public void testResumeFromReservedWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Check is Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check not changed
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.suspend( taskId, users.get( "bobba" ).getId(), responseHandler );
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );      
-    }     
-          
-    public void testSkipFromReady() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { skipable = true} ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ] }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();                     
-        
-        // Check is Complete
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.skip( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Obsolete, task1.getTaskData().getStatus() );
-        assertNull(  task1.getTaskData().getActualOwner() );                  
-    }    
-    
-    public void testSkipFromReserved() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { skipable = true} ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ] }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready 
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        // Check is Complete
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.skip( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Obsolete, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );                  
-    }     
-    
-    public void testDelegateFromReady() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );        
-        long taskId = addTaskResponseHandler.getTaskId();                     
-        
-        // Check is Delegated
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.delegate( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );        
-        Task task2 = getTaskResponseHandler.getTask();
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
-        assertEquals( users.get( "tony" ), task2.getTaskData().getActualOwner() );
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
-    }     
-    
-    public void testDelegateFromReserved() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Claim and Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Delegated
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.delegate( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );        
-        Task task2 = getTaskResponseHandler.getTask();
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
-        assertEquals( users.get( "tony" ), task2.getTaskData().getActualOwner() );
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
-    }     
-    
-    public void testDelegateFromReservedWithIncorrectUser() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Claim and Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check was not delegated
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.delegate( taskId, users.get( "bobba" ).getId(), users.get( "tony" ).getId(), responseHandler );    
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );        
-        Task task2 = getTaskResponseHandler.getTask();
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
-        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
-        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );             
-    }  
-    
-    public void testForwardFromReady() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();                     
-        
-        // Check is Forwarded
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.forward( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );        
-        Task task2 = getTaskResponseHandler.getTask();
-        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
-        assertNull( task2.getTaskData().getActualOwner() );
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
-    }  
-    
-    public void testForwardFromReserved() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Claim and Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Delegated
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.forward( taskId, users.get( "darth" ).getId(), users.get( "tony" ).getId(), responseHandler );    
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );        
-        Task task2 = getTaskResponseHandler.getTask();
-        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
-        assertNull( task2.getTaskData().getActualOwner() );
-        assertEquals(  Status.Ready, task2.getTaskData().getStatus() );             
-    }     
-    
-    public void testForwardFromReservedWithIncorrectUser() throws Exception {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Claim and Reserved
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.claim( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Reserved, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check was not delegated
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.forward( taskId, users.get( "bobba" ).getId(), users.get( "tony" ).getId(), responseHandler );    
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );        
-        Task task2 = getTaskResponseHandler.getTask();
-        assertTrue( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "darth" ) ) );
-        assertFalse( task2.getPeopleAssignments().getPotentialOwners().contains( users.get( "tony" ) ) );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );
-        assertEquals(  Status.Reserved, task2.getTaskData().getStatus() );             
-    }      
-    
-    public void testComplete() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Complete
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete( taskId, users.get( "darth" ).getId(), null, responseHandler ); 
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Completed, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
-    }
-        
-    public void testCompleteWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );        
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Should not complete as wrong user
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete( taskId, users.get( "bobba" ).getId(), null, responseHandler );  
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
-    }    
-
-    public void testCompleteWithContent() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        ContentData data = new ContentData();
-        data.setAccessType(AccessType.Inline);
-        data.setType("type");
-        data.setContent("content".getBytes());
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.complete( taskId, users.get( "darth" ).getId(), data, responseHandler ); 
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals( AccessType.Inline, task2.getTaskData().getOutputAccessType() );
-        assertEquals( "type", task2.getTaskData().getOutputType() );
-        long contentId = task2.getTaskData().getOutputContentId();
-        assertTrue( contentId != -1 ); 
-        
-        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
-        client.getContent(contentId, getContentResponseHandler);
-        Content content = getContentResponseHandler.getContent();
-        assertEquals("content", new String(content.getContent()));
-    }
-        
-    public void testFail() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Check is Failed
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.fail( taskId, users.get( "darth" ).getId(), null, responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.Failed, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
-    }
-    
-    public void testFailWithIncorrectUser() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );      
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        // Should not fail as wrong user
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.fail( taskId, users.get( "bobba" ).getId(), null, responseHandler );
-        PermissionDeniedException denied = null;
-        try{
-            responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        } catch(PermissionDeniedException e) {
-            denied = e;
-        }
-        assertNotNull("Should get permissed denied exception", denied);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task2.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task2.getTaskData().getActualOwner() );                  
-    }    
-
-    public void testFailWithContent() {
-        Map  vars = new HashedMap();     
-        vars.put( "users", users );
-        vars.put( "groups", groups );        
-        vars.put( "now", new Date() );
-        
-        // One potential owner, should go straight to state Reserved
-        String str = "(with (new Task()) { priority = 55, taskData = (with( new TaskData()) { } ), ";
-        str += "peopleAssignments = (with ( new PeopleAssignments() ) { potentialOwners = [users['bobba' ], users['darth'] ], }),";                        
-        str += "names = [ new I18NText( 'en-UK', 'This is my task name')] })";
-            
-        BlockingAddTaskResponseHandler addTaskResponseHandler = new BlockingAddTaskResponseHandler();
-        Task task = ( Task )  eval( new StringReader( str ), vars );
-        client.addTask( task, null, addTaskResponseHandler );
-        
-        long taskId = addTaskResponseHandler.getTaskId();             
-        
-        // Go straight from Ready to Inprogress
-        BlockingTaskOperationResponseHandler responseHandler = new BlockingTaskOperationResponseHandler();
-        client.start( taskId, users.get( "darth" ).getId(), responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        BlockingGetTaskResponseHandler getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task1 = getTaskResponseHandler.getTask();
-        assertEquals(  Status.InProgress, task1.getTaskData().getStatus() );
-        assertEquals( users.get( "darth" ), task1.getTaskData().getActualOwner() );  
-        
-        FaultData data = new FaultData();
-        data.setAccessType(AccessType.Inline);
-        data.setType("type");
-        data.setFaultName("faultName");
-        data.setContent("content".getBytes());
-        responseHandler = new BlockingTaskOperationResponseHandler();
-        client.fail( taskId, users.get( "darth" ).getId(), data, responseHandler );
-        responseHandler.waitTillDone(DEFAULT_WAIT_TIME);
-        
-        getTaskResponseHandler = new BlockingGetTaskResponseHandler();  
-        client.getTask( taskId, getTaskResponseHandler );
-        Task task2 = getTaskResponseHandler.getTask();
-        assertEquals( Status.Failed, task2.getTaskData().getStatus() );
-        assertEquals( AccessType.Inline, task2.getTaskData().getFaultAccessType() );
-        assertEquals( "type", task2.getTaskData().getFaultType() );
-        assertEquals( "faultName", task2.getTaskData().getFaultName() );
-        long contentId = task2.getTaskData().getFaultContentId();
-        assertTrue( contentId != -1 ); 
-        
-        BlockingGetContentResponseHandler getContentResponseHandler = new BlockingGetContentResponseHandler();
-        client.getContent(contentId, getContentResponseHandler);
-        Content content = getContentResponseHandler.getContent();
-        assertEquals("content", new String(content.getContent()));
-    }
-    
-}

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/IcalHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/IcalHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/IcalHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,44 @@
+package org.drools.task.service.hornetq;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.IcalBaseTest;
+import org.drools.task.service.TaskClient;
+import org.drools.util.ChainedProperties;
+import org.drools.util.ClassLoaderUtil;
+import org.subethamail.wiser.Wiser;
+
+public class IcalHornetQTest extends IcalBaseTest {
+
+	private HornetQTaskServer server;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        ChainedProperties props = new ChainedProperties("process.email.conf", ClassLoaderUtil.getClassLoader(null, getClass(), false ));
+        setEmailHost(props.getProperty("host", "locahost"));
+        setEmailPort(props.getProperty("port", "2345"));        
+        
+        server = new HornetQTaskServer(taskService, 5446);
+        Thread thread = new Thread(server);
+        thread.start();
+        Thread.sleep(500);
+
+        setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+        					new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 5446);
+
+        setWiser(new Wiser());
+        getWiser().setHostname(getEmailHost());
+        getWiser().setPort(Integer.parseInt(getEmailPort()));         
+        getWiser().start();
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        getClient().disconnect();
+        server.stop();
+        getWiser().stop();
+    }
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/IcalHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskLifeCycleHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskLifeCycleHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskLifeCycleHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,29 @@
+package org.drools.task.service.hornetq;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskLifeCycleBaseTest;
+
+public class TaskLifeCycleHornetQTest extends TaskLifeCycleBaseTest {
+
+	private HornetQTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new HornetQTaskServer(taskService, 5446);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+		setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+								new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 5446);
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+	}    
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskLifeCycleHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceCommentsAndAttachmentsHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceCommentsAndAttachmentsHornetQTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceCommentsAndAttachmentsHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -6,23 +6,24 @@
 
 public class TaskServiceCommentsAndAttachmentsHornetQTest extends TaskServiceCommentsAndAttachmentsBaseTest {
 
-	HornetQTaskServer server;
+	private HornetQTaskServer server;
 
 	@Override
 	protected void setUp() throws Exception {
 		super.setUp();
-		server = new HornetQTaskServer( taskService, 5446);
-        Thread thread = new Thread( server );
+		server = new HornetQTaskServer(taskService, 5446);
+        Thread thread = new Thread(server);
         thread.start();
-        Thread.sleep( 500 );
-        client = new TaskClient(new HornetQTaskClientConnector("client 1",
-                                new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 5446);
+        Thread.sleep(500);
+        
+        setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+                                new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 5446);
 	}
 
 	protected void tearDown() throws Exception {
 		super.tearDown();
-		client.disconnect();
+		getClient().disconnect();
 		server.stop();
 	}
 

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceDeadlinesHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceDeadlinesHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceDeadlinesHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,47 @@
+package org.drools.task.service.hornetq;
+
+import java.util.Properties;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceDeadlinesBaseTest;
+import org.subethamail.wiser.Wiser;
+
+public class TaskServiceDeadlinesHornetQTest extends TaskServiceDeadlinesBaseTest {
+
+	private HornetQTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {        
+		super.setUp();
+
+		setConf(new Properties());
+		getConf().setProperty("mail.smtp.host", "localhost");
+		getConf().setProperty("mail.smtp.port", "2345");
+		getConf().setProperty("from", "from at domain.com");
+		getConf().setProperty("replyTo", "replyTo at domain.com");
+		getConf().setProperty("defaultLanguage", "en-UK");
+
+		server = new HornetQTaskServer(taskService, 5446);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+
+		setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+								new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 5446);
+
+		setWiser(new Wiser());
+		getWiser().setHostname(getConf().getProperty("mail.smtp.host"));
+		getWiser().setPort(Integer.parseInt(getConf().getProperty("mail.smtp.port")));        
+		getWiser().start();
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+		getWiser().stop();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceDeadlinesHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEscalationHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEscalationHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEscalationHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,30 @@
+package org.drools.task.service.hornetq;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceEscalationBaseTest;
+
+public class TaskServiceEscalationHornetQTest extends TaskServiceEscalationBaseTest {
+
+	private HornetQTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new HornetQTaskServer(taskService, 5446);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+
+		setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+								new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 5446);
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEscalationHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEventMessagingHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEventMessagingHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEventMessagingHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,39 @@
+package org.drools.task.service.hornetq;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.MockUserInfo;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceEventMessagingBaseTest;
+
+public class TaskServiceEventMessagingHornetQTest extends TaskServiceEventMessagingBaseTest {
+
+	private HornetQTaskServer server;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        server = new HornetQTaskServer(taskService, 5446);
+        Thread thread = new Thread(server);
+        thread.start();
+        Thread.sleep(500);
+        
+        setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+                                new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 9123);
+        
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put(users.get("tony"), "tony at domain.com");
+        userInfo.getEmails().put(users.get("steve"), "steve at domain.com");
+
+        userInfo.getLanguages().put(users.get("tony"), "en-UK");
+        userInfo.getLanguages().put(users.get("steve"), "en-UK");
+        taskService.setUserinfo(userInfo);
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        getClient().disconnect();
+        server.stop();
+    }    
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceEventMessagingHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceHornetQTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -6,7 +6,7 @@
 
 public class TaskServiceHornetQTest extends TaskServiceBaseTest {
 
-	HornetQTaskServer server;
+	private HornetQTaskServer server;
 
     @Override
     protected void setUp() throws Exception {
@@ -15,14 +15,14 @@
         Thread thread = new Thread( server );
         thread.start();
         Thread.sleep( 500 );
-        client = new TaskClient(new HornetQTaskClientConnector("client 1",
-                                new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 5446);
+        setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+                                new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 5446);
     }
 
     protected void tearDown() throws Exception {
         super.tearDown();
-        client.disconnect();
+        getClient().disconnect();
         server.stop();
     }
 

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceLifeCycleHornetQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceLifeCycleHornetQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceLifeCycleHornetQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,30 @@
+package org.drools.task.service.hornetq;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceLifeCycleBaseTest;
+
+public class TaskServiceLifeCycleHornetQTest extends TaskServiceLifeCycleBaseTest {
+
+	private HornetQTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new HornetQTaskServer(taskService, 5446);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+
+		setClient(new TaskClient(new HornetQTaskClientConnector("client 1",
+								new TaskHornetQClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 5446);
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/hornetq/TaskServiceLifeCycleHornetQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/IcalMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/IcalMinaTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/IcalMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,47 @@
+package org.drools.task.service.mina;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.IcalBaseTest;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+import org.drools.util.ChainedProperties;
+import org.drools.util.ClassLoaderUtil;
+import org.subethamail.wiser.Wiser;
+
+public class IcalMinaTest extends IcalBaseTest {
+
+	private MinaTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+
+		ChainedProperties props = new ChainedProperties("process.email.conf", ClassLoaderUtil.getClassLoader(null, getClass(), false) );
+		setEmailHost(props.getProperty("host", "locahost"));
+		setEmailPort(props.getProperty("port", "2345"));        
+
+		server = new MinaTaskServer(taskService);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+
+		setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+						new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 9123);
+
+		setWiser(new Wiser());
+		getWiser().setHostname(getEmailHost());
+		getWiser().setPort( Integer.parseInt(getEmailPort()));         
+		getWiser().start();
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+		getWiser().stop();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/IcalMinaTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskLifeCycleMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskLifeCycleMinaTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskLifeCycleMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,32 @@
+package org.drools.task.service.mina;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskLifeCycleBaseTest;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+
+public class TaskLifeCycleMinaTest extends TaskLifeCycleBaseTest {
+
+	private MinaTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new MinaTaskServer(taskService);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+		setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+								new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 9123);
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+	}    
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskLifeCycleMinaTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceCommentsAndAttachmentsMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceCommentsAndAttachmentsMinaTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceCommentsAndAttachmentsMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -6,7 +6,7 @@
 
 public class TaskServiceCommentsAndAttachmentsMinaTest extends TaskServiceCommentsAndAttachmentsBaseTest {
 
-	MinaTaskServer server;
+	private MinaTaskServer server;
 
 	@Override
 	protected void setUp() throws Exception {
@@ -16,14 +16,14 @@
 		thread.start();
 		Thread.sleep( 500 );
 
-		client = new TaskClient(new MinaTaskClientConnector("client 1",
-								new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-		client.connect("127.0.0.1", 9123);
+		setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+								new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 9123);
 	}
 
 	protected void tearDown() throws Exception {
 		super.tearDown();
-		client.disconnect();
+		getClient().disconnect();
 		server.stop();
 	}
 

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceDeadlinesMinaQTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceDeadlinesMinaQTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceDeadlinesMinaQTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,50 @@
+package org.drools.task.service.mina;
+
+import java.util.Properties;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceDeadlinesBaseTest;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+import org.subethamail.wiser.Wiser;
+
+public class TaskServiceDeadlinesMinaQTest extends TaskServiceDeadlinesBaseTest {
+
+	private MinaTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {        
+		super.setUp();
+
+		setConf(new Properties());
+		getConf().setProperty("mail.smtp.host", "localhost");
+		getConf().setProperty("mail.smtp.port", "2345");
+		getConf().setProperty("from", "from at domain.com");
+		getConf().setProperty("replyTo", "replyTo at domain.com");
+		getConf().setProperty("defaultLanguage", "en-UK");
+
+		server = new MinaTaskServer(taskService);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+
+		setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+								new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 9123);
+
+		setWiser(new Wiser());
+		getWiser().setHostname(getConf().getProperty("mail.smtp.host"));
+		getWiser().setPort(Integer.parseInt(getConf().getProperty("mail.smtp.port")));        
+		getWiser().start();
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+		getWiser().stop();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceDeadlinesMinaQTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEscalationMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEscalationMinaTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEscalationMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,33 @@
+package org.drools.task.service.mina;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceEscalationBaseTest;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+
+public class TaskServiceEscalationMinaTest extends TaskServiceEscalationBaseTest {
+
+	private MinaTaskServer server;
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		server = new MinaTaskServer(taskService);
+		Thread thread = new Thread(server);
+		thread.start();
+		Thread.sleep(500);
+
+		setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+								new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+		getClient().connect("127.0.0.1", 9123);
+	}
+
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		getClient().disconnect();
+		server.stop();
+	}
+
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEscalationMinaTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEventMessagingMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEventMessagingMinaTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEventMessagingMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,42 @@
+package org.drools.task.service.mina;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.MockUserInfo;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceEventMessagingBaseTest;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+
+public class TaskServiceEventMessagingMinaTest extends TaskServiceEventMessagingBaseTest {
+
+	private MinaTaskServer server;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        server = new MinaTaskServer(taskService);
+        Thread thread = new Thread(server);
+        thread.start();
+        Thread.sleep(500);
+        
+        setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+                                new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 9123);
+        
+        MockUserInfo userInfo = new MockUserInfo();
+        userInfo.getEmails().put(users.get("tony"), "tony at domain.com");
+        userInfo.getEmails().put(users.get("steve"), "steve at domain.com");
+
+        userInfo.getLanguages().put(users.get("tony"), "en-UK");
+        userInfo.getLanguages().put(users.get("steve"), "en-UK");
+        taskService.setUserinfo(userInfo);
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        getClient().disconnect();
+        server.stop();
+    }    
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceEventMessagingMinaTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Added: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceLifeCycleMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceLifeCycleMinaTest.java	                        (rev 0)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceLifeCycleMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -0,0 +1,33 @@
+package org.drools.task.service.mina;
+
+import org.drools.SystemEventListenerFactory;
+import org.drools.task.service.TaskClient;
+import org.drools.task.service.TaskServiceLifeCycleBaseTest;
+import org.drools.task.service.mina.MinaTaskClientConnector;
+import org.drools.task.service.mina.MinaTaskServer;
+import org.drools.task.service.mina.TaskMinaClientHandler;
+
+public class TaskServiceLifeCycleMinaTest extends TaskServiceLifeCycleBaseTest {
+
+	private MinaTaskServer server;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        server = new MinaTaskServer(taskService);
+        Thread thread = new Thread(server);
+        thread.start();
+        Thread.sleep(500);
+
+        setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+                                     new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 9123);
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        getClient().disconnect();
+        server.stop();
+    }
+    
+}


Property changes on: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceLifeCycleMinaTest.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:eol-style
   + native

Modified: labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceMinaTest.java
===================================================================
--- labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceMinaTest.java	2010-05-19 03:22:33 UTC (rev 32946)
+++ labs/jbossrules/branches/remote_implementation_using_hornetq-lucaz/drools-process/drools-process-task/src/test/java/org/drools/task/service/mina/TaskServiceMinaTest.java	2010-05-19 03:26:46 UTC (rev 32947)
@@ -9,7 +9,7 @@
 
 public class TaskServiceMinaTest extends TaskServiceBaseTest {
 
-	MinaTaskServer server;
+	private MinaTaskServer server;
 
     @Override
     protected void setUp() throws Exception {
@@ -18,14 +18,14 @@
         Thread thread = new Thread( server );
         thread.start();
         Thread.sleep( 500 );
-        client = new TaskClient(new MinaTaskClientConnector("client 1",
-                                new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener())));
-        client.connect("127.0.0.1", 9123);
+        setClient(new TaskClient(new MinaTaskClientConnector("client 1",
+                                new TaskMinaClientHandler(SystemEventListenerFactory.getSystemEventListener()))));
+        getClient().connect("127.0.0.1", 9123);
     }
 
     protected void tearDown() throws Exception {
         super.tearDown();
-        client.disconnect();
+        getClient().disconnect();
         server.stop();
     }
 

