Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModelTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModelTest.java	(revision 1146)
+++ trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskModelTest.java	(revision 1146)
@@ -0,0 +1,1246 @@
+//   Copyright 2012 Georg-August-Universität Göttingen, Germany
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+package de.ugoe.cs.autoquest.tasktrees.treeimpl;
+
+import static org.junit.Assert.*;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+import de.ugoe.cs.autoquest.eventcore.IEventTarget;
+import de.ugoe.cs.autoquest.eventcore.IEventType;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IOptional;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInfo;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskInfo;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskBuilder;
+import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskFactory;
+import de.ugoe.cs.autoquest.test.DummyGUIElement;
+import de.ugoe.cs.autoquest.test.DummyInteraction;
+
+/**
+ * TODO comment
+ * 
+ * @version $Revision: $ $Date: 02.04.2012$
+ * @author 2012, last modified by $Author: patrick$
+ */
+public class TaskModelTest {
+    
+    /** */
+    private static final int MAX_TREE_DEPTH = 15;
+
+    /** */
+    private ITaskBuilder taskBuilder = new TaskBuilder();
+
+    /** */
+    private ITaskFactory taskFactory = new TaskFactory();
+
+    /**
+     *
+     */
+    @Test
+    public void test_EventTask_01() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        assertNotNull(task);
+        assertNotNull(task.getDescription());
+        assertNotNull(task.getId());
+        assertTrue(task.equals(task));
+        
+        assertEquals(eventType, task.getEventType());
+        assertEquals(eventTarget, task.getEventTarget());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_EventTask_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        // the tasks will not be equal as they should have a different id
+        assertFalse(task1.equals(task2));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_EventTask_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task);
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task);
+        
+        assertFalse(taskInstance1.equals(taskInstance2));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Sequence_01() throws Exception {
+        ISequence task = taskFactory.createNewSequence();
+        
+        assertNotNull(task);
+        assertNotNull(task.getDescription());
+        assertNotNull(task.getId());
+        assertNotNull(task.getChildren());
+        assertEquals(0, task.getChildren().size());
+        assertTrue(task.equals(task));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Sequence_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        ISequence task = taskFactory.createNewSequence();
+        
+        taskBuilder.addChild(task, child);
+        
+        assertNotNull(task.getChildren());
+        assertEquals(1, task.getChildren().size());
+        assertEquals(child, task.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Sequence_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child3 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child4 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child5 = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        ISequence task = taskFactory.createNewSequence();
+        
+        taskBuilder.addChild(task, child1);
+        taskBuilder.addChild(task, child2);
+        taskBuilder.addChild(task, child3);
+        taskBuilder.addChild(task, child4);
+        taskBuilder.addChild(task, child5);
+        
+        assertNotNull(task.getChildren());
+        assertEquals(5, task.getChildren().size());
+        assertEquals(child1, task.getChildren().get(0));
+        assertEquals(child2, task.getChildren().get(1));
+        assertEquals(child3, task.getChildren().get(2));
+        assertEquals(child4, task.getChildren().get(3));
+        assertEquals(child5, task.getChildren().get(4));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Selection_01() throws Exception {
+        ISelection task = taskFactory.createNewSelection();
+        
+        assertNotNull(task);
+        assertNotNull(task.getDescription());
+        assertNotNull(task.getId());
+        assertNotNull(task.getChildren());
+        assertEquals(0, task.getChildren().size());
+        assertTrue(task.equals(task));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Selection_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        ISelection task = taskFactory.createNewSelection();
+        
+        taskBuilder.addChild(task, child);
+        
+        assertNotNull(task.getChildren());
+        assertEquals(1, task.getChildren().size());
+        assertEquals(child, task.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Selection_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child3 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child4 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child5 = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        ISelection task = taskFactory.createNewSelection();
+        
+        taskBuilder.addChild(task, child1);
+        taskBuilder.addChild(task, child2);
+        taskBuilder.addChild(task, child3);
+        taskBuilder.addChild(task, child4);
+        taskBuilder.addChild(task, child5);
+        
+        assertNotNull(task.getChildren());
+        assertEquals(5, task.getChildren().size());
+        assertEquals(child1, task.getChildren().get(0));
+        assertEquals(child2, task.getChildren().get(1));
+        assertEquals(child3, task.getChildren().get(2));
+        assertEquals(child4, task.getChildren().get(3));
+        assertEquals(child5, task.getChildren().get(4));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Iteration_01() throws Exception {
+        IIteration task = taskFactory.createNewIteration();
+        
+        assertNotNull(task);
+        assertNotNull(task.getDescription());
+        assertNotNull(task.getId());
+        assertNull(task.getMarkedTask());
+        assertTrue(task.equals(task));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Iteration_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        IIteration task = taskFactory.createNewIteration();
+        
+        taskBuilder.setMarkedTask(task, child);
+        
+        assertEquals(child, task.getMarkedTask());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Iteration_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        IIteration task = taskFactory.createNewIteration();
+        
+        taskBuilder.setMarkedTask(task, child1);
+        taskBuilder.setMarkedTask(task, child2);
+        
+        assertEquals(child2, task.getMarkedTask());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Optional_01() throws Exception {
+        IOptional task = taskFactory.createNewOptional();
+        
+        assertNotNull(task);
+        assertNotNull(task.getDescription());
+        assertNotNull(task.getId());
+        assertNull(task.getMarkedTask());
+        assertTrue(task.equals(task));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Optional_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        IOptional task = taskFactory.createNewOptional();
+        
+        taskBuilder.setMarkedTask(task, child);
+        
+        assertEquals(child, task.getMarkedTask());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_Optional_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask child1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask child2 = taskFactory.createNewEventTask(eventType, eventTarget);
+
+        IOptional task = taskFactory.createNewOptional();
+        
+        taskBuilder.setMarkedTask(task, child1);
+        taskBuilder.setMarkedTask(task, child2);
+        
+        assertEquals(child2, task.getMarkedTask());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_EventTaskInstance_01() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        
+        assertNotNull(taskInstance);
+        assertEquals(task, taskInstance.getTask());
+        assertTrue(taskInstance.equals(taskInstance));
+        assertFalse(taskInstance.equals(task));
+        assertNotNull(taskInstance.getChildren());
+        assertEquals(0, taskInstance.getChildren().size());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_EventTaskInstance_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task);
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task);
+        
+        assertFalse(taskInstance1.equals(taskInstance2));
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_EventTaskInstance_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task);
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task);
+        
+        taskBuilder.addChild(taskInstance1, taskInstance2);
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_SequenceInstance_01() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ISequence sequence = taskFactory.createNewSequence();
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence);
+        
+        taskBuilder.addChild(sequenceInstance, taskInstance);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_SequenceInstance_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ISequence sequence = taskFactory.createNewSequence();
+        taskBuilder.addChild(sequence, task);
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence);
+        
+        taskBuilder.addChild(sequenceInstance, taskInstance);
+        
+        assertNotNull(sequenceInstance.getChildren());
+        assertEquals(1, sequenceInstance.getChildren().size());
+        assertEquals(taskInstance, sequenceInstance.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_SequenceInstance_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task3 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task4 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task5 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ISequence sequence = taskFactory.createNewSequence();
+        taskBuilder.addChild(sequence, task1);
+        taskBuilder.addChild(sequence, task2);
+        taskBuilder.addChild(sequence, task3);
+        taskBuilder.addChild(sequence, task4);
+        taskBuilder.addChild(sequence, task5);
+        
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1);
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2);
+        ITaskInstance taskInstance3 = taskFactory.createNewTaskInstance(task3);
+        ITaskInstance taskInstance4 = taskFactory.createNewTaskInstance(task4);
+        ITaskInstance taskInstance5 = taskFactory.createNewTaskInstance(task5);
+        ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence);
+        
+        taskBuilder.addChild(sequenceInstance, taskInstance1);
+        taskBuilder.addChild(sequenceInstance, taskInstance2);
+        taskBuilder.addChild(sequenceInstance, taskInstance3);
+        taskBuilder.addChild(sequenceInstance, taskInstance4);
+        taskBuilder.addChild(sequenceInstance, taskInstance5);
+        
+        assertNotNull(sequenceInstance.getChildren());
+        assertEquals(5, sequenceInstance.getChildren().size());
+        assertEquals(taskInstance1, sequenceInstance.getChildren().get(0));
+        assertEquals(taskInstance2, sequenceInstance.getChildren().get(1));
+        assertEquals(taskInstance3, sequenceInstance.getChildren().get(2));
+        assertEquals(taskInstance4, sequenceInstance.getChildren().get(3));
+        assertEquals(taskInstance5, sequenceInstance.getChildren().get(4));
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_SelectionInstance_01() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ISelection selection = taskFactory.createNewSelection();
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection);
+        
+        taskBuilder.addChild(selectionInstance, taskInstance);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_SelectionInstance_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ISelection selection = taskFactory.createNewSelection();
+        taskBuilder.addChild(selection, task);
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection);
+        
+        taskBuilder.addChild(selectionInstance, taskInstance);
+        
+        assertNotNull(selectionInstance.getChildren());
+        assertEquals(1, selectionInstance.getChildren().size());
+        assertEquals(taskInstance, selectionInstance.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_SelectionInstance_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task3 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task4 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task5 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        ISelection selection = taskFactory.createNewSelection();
+        taskBuilder.addChild(selection, task1);
+        taskBuilder.addChild(selection, task2);
+        taskBuilder.addChild(selection, task3);
+        taskBuilder.addChild(selection, task4);
+        taskBuilder.addChild(selection, task5);
+        
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1);
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2);
+        ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection);
+        
+        taskBuilder.addChild(selectionInstance, taskInstance1);
+        taskBuilder.addChild(selectionInstance, taskInstance2);
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_IterationInstance_01() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IIteration iteration = taskFactory.createNewIteration();
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration);
+        
+        taskBuilder.addChild(iterationInstance, taskInstance);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_IterationInstance_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IIteration iteration = taskFactory.createNewIteration();
+        taskBuilder.setMarkedTask(iteration, task);
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration);
+        
+        taskBuilder.addChild(iterationInstance, taskInstance);
+        
+        assertNotNull(iterationInstance.getChildren());
+        assertEquals(1, iterationInstance.getChildren().size());
+        assertEquals(taskInstance, iterationInstance.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_IterationInstance_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IIteration iteration = taskFactory.createNewIteration();
+        taskBuilder.setMarkedTask(iteration, task1);
+        taskBuilder.setMarkedTask(iteration, task2);
+        
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1);
+        ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration);
+        
+        taskBuilder.addChild(iterationInstance, taskInstance1);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_IterationInstance_04() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IIteration iteration = taskFactory.createNewIteration();
+        taskBuilder.setMarkedTask(iteration, task1);
+        taskBuilder.setMarkedTask(iteration, task2);
+        
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2);
+        ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration);
+        
+        taskBuilder.addChild(iterationInstance, taskInstance2);
+        
+        assertNotNull(iterationInstance.getChildren());
+        assertEquals(1, iterationInstance.getChildren().size());
+        assertEquals(taskInstance2, iterationInstance.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_OptionalInstance_01() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IOptional optional = taskFactory.createNewOptional();
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional);
+        
+        taskBuilder.addChild(optionalInstance, taskInstance);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_OptionalInstance_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IOptional optional = taskFactory.createNewOptional();
+        taskBuilder.setMarkedTask(optional, task);
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional);
+        
+        taskBuilder.addChild(optionalInstance, taskInstance);
+        
+        assertNotNull(optionalInstance.getChildren());
+        assertEquals(1, optionalInstance.getChildren().size());
+        assertEquals(taskInstance, optionalInstance.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test(expected=IllegalArgumentException.class)
+    public void test_OptionalInstance_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IOptional optional = taskFactory.createNewOptional();
+        taskBuilder.setMarkedTask(optional, task1);
+        taskBuilder.setMarkedTask(optional, task2);
+        
+        ITaskInstance taskInstance1 = taskFactory.createNewTaskInstance(task1);
+        ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional);
+        
+        taskBuilder.addChild(optionalInstance, taskInstance1);
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_OptionalInstance_04() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task1 = taskFactory.createNewEventTask(eventType, eventTarget);
+        IEventTask task2 = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IOptional optional = taskFactory.createNewOptional();
+        taskBuilder.setMarkedTask(optional, task1);
+        taskBuilder.setMarkedTask(optional, task2);
+        
+        ITaskInstance taskInstance2 = taskFactory.createNewTaskInstance(task2);
+        ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional);
+        
+        taskBuilder.addChild(optionalInstance, taskInstance2);
+        
+        assertNotNull(optionalInstance.getChildren());
+        assertEquals(1, optionalInstance.getChildren().size());
+        assertEquals(taskInstance2, optionalInstance.getChildren().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_UserSession_01() throws Exception {
+        IUserSession userSession = taskFactory.createUserSession();
+        
+        assertNotNull(userSession);
+        assertNotNull(userSession.getExecutedTasks());
+        assertEquals(0, userSession.getExecutedTasks().size());
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_UserSession_02() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        
+        IUserSession userSession = taskFactory.createUserSession();
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        
+        taskBuilder.addExecutedTask(userSession, taskInstance);
+        
+        assertNotNull(userSession.getExecutedTasks());
+        assertEquals(1, userSession.getExecutedTasks().size());
+        assertEquals(taskInstance, userSession.getExecutedTasks().get(0));
+    }
+
+    /**
+     *
+     */
+    @Test
+    public void test_UserSession_03() throws Exception {
+        IEventType eventType = new DummyInteraction("interaction", 1);
+        IEventTarget eventTarget = new DummyGUIElement("elem");
+        
+        IEventTask task = taskFactory.createNewEventTask(eventType, eventTarget);
+        ISequence sequence = taskFactory.createNewSequence();
+        ISelection selection = taskFactory.createNewSelection();
+        IIteration iteration = taskFactory.createNewIteration();
+        IOptional optional = taskFactory.createNewOptional();
+        
+        taskBuilder.addChild(sequence, task);
+        taskBuilder.addChild(selection, task);
+        taskBuilder.setMarkedTask(iteration, task);
+        taskBuilder.setMarkedTask(optional, task);
+        
+        ITaskInstance taskInstance = taskFactory.createNewTaskInstance(task);
+        ITaskInstance sequenceInstance = taskFactory.createNewTaskInstance(sequence);
+        ITaskInstance selectionInstance = taskFactory.createNewTaskInstance(selection);
+        ITaskInstance iterationInstance = taskFactory.createNewTaskInstance(iteration);
+        ITaskInstance optionalInstance = taskFactory.createNewTaskInstance(optional);
+        
+        taskBuilder.addChild(sequenceInstance, taskFactory.createNewTaskInstance(task));
+        taskBuilder.addChild(selectionInstance, taskFactory.createNewTaskInstance(task));
+        taskBuilder.addChild(iterationInstance, taskFactory.createNewTaskInstance(task));
+        taskBuilder.addChild(optionalInstance, taskFactory.createNewTaskInstance(task));
+        
+        IUserSession userSession = taskFactory.createUserSession();
+        
+        taskBuilder.addExecutedTask(userSession, taskInstance);
+        taskBuilder.addExecutedTask(userSession, sequenceInstance);
+        taskBuilder.addExecutedTask(userSession, selectionInstance);
+        taskBuilder.addExecutedTask(userSession, iterationInstance);
+        taskBuilder.addExecutedTask(userSession, optionalInstance);
+        
+        assertNotNull(userSession.getExecutedTasks());
+        assertEquals(5, userSession.getExecutedTasks().size());
+        assertEquals(taskInstance, userSession.getExecutedTasks().get(0));
+        assertEquals(sequenceInstance, userSession.getExecutedTasks().get(1));
+        assertEquals(selectionInstance, userSession.getExecutedTasks().get(2));
+        assertEquals(iterationInstance, userSession.getExecutedTasks().get(3));
+        assertEquals(optionalInstance, userSession.getExecutedTasks().get(4));
+    }
+    
+    /**
+     *
+     */
+    @Test
+    public void testRandomTrees() throws Exception {
+        int noOfTrees = 10;
+        int noOfMaxChildren = 8;
+        int maxDepth = MAX_TREE_DEPTH;
+
+        for (int i = 0; i < noOfTrees; i++) {
+            System.err.println("\niteration " + (i + 1) + ":");
+            System.err.println("  creating tasks");
+            Map<ITask, ITaskInfo> expectedTaskInfos = new HashMap<ITask, ITaskInfo>();
+            ITask task = createTaskTree(noOfMaxChildren, maxDepth, expectedTaskInfos);
+            if (!(task instanceof ISequence)) {
+                ISequence sequence = taskFactory.createNewSequence();
+                taskBuilder.addChild(sequence, task);
+                task = sequence;
+            }
+            else {
+                expectedTaskInfos.remove(task);
+            }
+            
+            ITaskInstance taskInstance = instantiateTask(task, noOfMaxChildren);
+            
+            System.err.println("  creating user session");
+            
+            IUserSession session = taskFactory.createUserSession();
+            
+            for (ITaskInstance child : taskInstance.getChildren()) {
+                taskBuilder.addExecutedTask(session, child);
+            }
+            
+            List<IUserSession> sessions = new LinkedList<IUserSession>();
+            sessions.add(session);
+            
+            ITaskModel taskTree = taskFactory.createTaskModel(sessions);
+
+            System.err.println("  validating task tree");
+            Map<ITask, ITaskInfo> actualTaskInfos = new HashMap<ITask, ITaskInfo>();
+            
+            for (ITask currentTask : taskTree.getTasks()) {
+                actualTaskInfos.put(currentTask, taskTree.getTaskInfo(currentTask));
+            }
+            
+            assertMapsEqual(expectedTaskInfos, actualTaskInfos);
+        }
+    }
+
+    /**
+     *
+     */
+    private void assertMapsEqual(Map<ITask, ITaskInfo> map1,
+                                 Map<ITask, ITaskInfo> map2)
+    {
+        try {
+            if (map1 == null) {
+                assertNull(map2);
+                return;
+            }
+
+            assertEquals(map1.size(), map2.size());
+
+            for (Map.Entry<ITask, ITaskInfo> entry : map1.entrySet()) {
+                ITaskInfo value2 = map2.get(entry.getKey());
+                assertNotNull(value2);
+                assertEquals(entry.getValue().getTask(), value2.getTask());
+                //assertEquals(entry.getValue().getNoOfOccurencesInTree(),
+                //             value2.getNoOfOccurencesInTree());
+            }
+        }
+        catch (AssertionError e) {
+            dumpMap(map1);
+            dumpMap(map2);
+            throw e;
+        }
+    }
+
+    /**
+     *
+     */
+    private void dumpMap(Map<ITask, ITaskInfo> map) {
+        System.err.println();
+
+        if (map == null) {
+            System.err.println("map is null");
+        }
+        else {
+            System.err.println("map:");
+            for (Map.Entry<ITask, ITaskInfo> entry : map.entrySet()) {
+                System.err.print("  ");
+                System.err.print(entry.getKey());
+                for (int i = entry.getKey().toString().length(); i < 60; i++) {
+                    System.err.print(" ");
+                }
+                System.err.print(" : ");
+                System.err.println(entry.getValue());
+            }
+        }
+
+        System.err.println();
+    }
+
+    /**
+     *
+     */
+    private ITask createTaskTree(int                   maxNoOfChildren,
+                                 int                   maxDepth,
+                                 Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+
+        ITask task;
+
+        // integrating the maximum depth here assures, that either something between 0 and 8 will
+        // be the type, or if the max depth decreases near 0 only event tasks will be created
+        // to finish the tree creation
+        int type = randomize(Math.min(10, maxDepth));
+
+        switch (type)
+        {
+            case 0: {
+                // System.err.print("creating new event task ");
+                task = createNewEventTask(taskInfos);
+                break;
+            }
+            case 1: {
+                // System.err.print("reusing event task ");
+                task = reuseEventTask(taskInfos);
+                break;
+            }
+            case 2: {
+                // System.err.println("creating new sequence {");
+                task = createNewSequence(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 3: {
+                // System.err.println("reusing sequence {");
+                task = reuseSequence(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 4: {
+                // System.err.println("creating new selection {");
+                task = createNewSelection(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 5: {
+                // System.err.println("reusing selection {");
+                task = reuseSelection(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 6: {
+                // System.err.println("creating new iteration {");
+                task = createNewIteration(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 7: {
+                // System.err.println("reusing iteration {");
+                task = reuseIteration(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 8: {
+                // System.err.println("creating new optional {");
+                task = createNewOptional(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            case 9: {
+                // System.err.println("reusing optional {");
+                task = reuseOptional(maxNoOfChildren, maxDepth, taskInfos);
+                break;
+            }
+            default: {
+                // System.err.print("creating new event task per default ");
+                task = createNewEventTask(taskInfos);
+            }
+        }
+
+        return task;
+    }
+
+    /**
+     *
+     */
+    private ITask createNewEventTask(Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        Thread.sleep(2);
+        long id = System.currentTimeMillis();
+        IEventTask task = taskFactory.createNewEventTask
+            (new DummyInteraction("interaction" + id, 1), new DummyGUIElement("elem" + id));
+
+        taskInfos.put(task, new TaskInfo(task));
+
+        return task;
+    }
+
+    /**
+     *
+     */
+    private ITask reuseEventTask(Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ITask eventTask = reuseTask(taskInfos, IEventTask.class);
+        
+        if (eventTask == null) {
+            eventTask = createNewEventTask(taskInfos);
+        }
+
+        return eventTask;
+    }
+
+    /**
+     *
+     */
+    private ITask createNewSequence(int                   maxNoOfChildren,
+                                    int                   maxDepth,
+                                    Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ISequence sequence = taskFactory.createNewSequence();
+
+        // ensure at the minimum 2 children
+        int noOfChildren = randomize(2, maxNoOfChildren);
+
+        for (int i = 0; i < noOfChildren; i++) {
+            ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos);
+            taskBuilder.addChild(sequence, child);
+        }
+
+        taskInfos.put(sequence, new TaskInfo(sequence));
+        return sequence;
+    }
+
+    /**
+     *
+     */
+    private ITask reuseSequence(int                   maxNoOfChildren,
+                                int                   maxDepth,
+                                Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ITask sequence = reuseTask(taskInfos, ISequence.class);
+        
+        if (sequence == null) {
+            sequence = createNewSequence(maxNoOfChildren, maxDepth, taskInfos);
+        }
+
+        return sequence;
+    }
+
+    /**
+     *
+     */
+    private ITask createNewSelection(int                   maxNoOfChildren,
+                                     int                   maxDepth,
+                                     Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ISelection selection = taskFactory.createNewSelection();
+
+        // ensure at the minimum 1 child
+        int noOfChildren = randomize(1, maxNoOfChildren);
+        
+        for (int i = 0; i < noOfChildren; i++) {
+            ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos);
+            taskBuilder.addChild(selection, child);
+        }
+
+        taskInfos.put(selection, new TaskInfo(selection));
+        return selection;
+    }
+
+    /**
+     *
+     */
+    private ITask reuseSelection(int                   maxNoOfChildren,
+                                 int                   maxDepth,
+                                 Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ITask selection = reuseTask(taskInfos, ISelection.class);
+        
+        if (selection == null) {
+            selection = createNewSelection(maxNoOfChildren, maxDepth, taskInfos);
+        }
+
+        return selection;
+    }
+
+    /**
+     * 
+     */
+    private ITask createNewIteration(int                   maxNoOfChildren,
+                                     int                   maxDepth,
+                                     Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        IIteration iteration = taskFactory.createNewIteration();
+
+        ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos);
+        taskBuilder.setMarkedTask(iteration, child);
+
+        taskInfos.put(iteration, new TaskInfo(iteration));
+        return iteration;
+    }
+
+    /**
+     *
+     */
+    private ITask reuseIteration(int                   maxNoOfChildren,
+                                 int                   maxDepth,
+                                 Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ITask iteration = reuseTask(taskInfos, IIteration.class);
+        
+        if (iteration == null) {
+            iteration = createNewIteration(maxNoOfChildren, maxDepth, taskInfos);
+        }
+
+        return iteration;
+    }
+
+    /**
+     * 
+     */
+    private ITask createNewOptional(int                   maxNoOfChildren,
+                                    int                   maxDepth,
+                                    Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        IOptional optional = taskFactory.createNewOptional();
+
+        ITask child = createTaskTree(maxNoOfChildren, maxDepth - 1, taskInfos);
+        taskBuilder.setMarkedTask(optional, child);
+
+        taskInfos.put(optional, new TaskInfo(optional));
+        return optional;
+    }
+
+    /**
+     *
+     */
+    private ITask reuseOptional(int                   maxNoOfChildren,
+                                int                   maxDepth,
+                                Map<ITask, ITaskInfo> taskInfos)
+        throws Exception
+    {
+        ITask optional = reuseTask(taskInfos, IOptional.class);
+        
+        if (optional == null) {
+            optional = createNewOptional(maxNoOfChildren, maxDepth, taskInfos);
+        }
+
+        return optional;
+    }
+
+    /**
+     *
+     */
+    private ITask reuseTask(Map<ITask, ITaskInfo> taskInfos, Class<? extends ITask> type)
+        throws Exception
+    {
+        int noOfTasks = 0;
+
+        for (Map.Entry<ITask, ITaskInfo> entry : taskInfos.entrySet()) {
+            if (type.isInstance(entry.getKey())) {
+                noOfTasks++;
+            }
+        }
+
+        if (noOfTasks > 0) {
+            noOfTasks = randomize(noOfTasks);
+
+            for (Map.Entry<ITask, ITaskInfo> entry : taskInfos.entrySet()) {
+                if (type.isInstance(entry.getKey())) {
+                    if (--noOfTasks <= 0) {
+                        return entry.getKey();
+                    }
+                }
+            }
+        }
+        else {
+            return null;
+        }
+
+        throw new RuntimeException("this is an implementation error");
+    }
+
+    /**
+     *
+     */
+    private ITaskInstance instantiateTask(ITask task, int maxIterationCount) throws Exception {
+        ITaskInstance instance = taskFactory.createNewTaskInstance(task);
+
+        if (task instanceof ISequence) {
+            for (ITask child : ((ISequence) task).getChildren()) {
+                taskBuilder.addChild(instance, instantiateTask(child, maxIterationCount));
+            }
+        }
+        else if (task instanceof ISelection) {
+            List<ITask> children = ((ISelection) task).getChildren();
+            int index = randomize(children.size());
+            taskBuilder.addChild(instance, instantiateTask(children.get(index), maxIterationCount));
+        }
+        else if (task instanceof IIteration) {
+            int count = randomize(maxIterationCount);
+            ITask child = ((IIteration) task).getMarkedTask();
+            
+            for (int i = 0; i < count; i++) {
+                taskBuilder.addChild(instance, instantiateTask(child, maxIterationCount));
+            }
+        }
+        else if (task instanceof IOptional) {
+            ITask child = ((IOptional) task).getMarkedTask();
+            
+            if (randomize(1) == 0) {
+                taskBuilder.addChild(instance, instantiateTask(child, maxIterationCount));
+            }
+        }
+        
+        return instance;
+    }
+
+    /**
+     *
+     */
+    private int randomize(int max) throws Exception {
+        return randomize(0, max);
+    }
+    
+    /**
+     *
+     */
+    private int randomize(int min, int max) throws Exception {
+        if (min > max) {
+            throw new IllegalArgumentException("min must always be smaller or equal than max");
+        }
+        
+        int deviation = max - min;
+        int value = (int) (Math.random() * deviation);
+        
+        return value + min;
+    }
+}
Index: trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java
===================================================================
--- trunk/autoquest-core-tasktrees-test/src/test/java/de/ugoe/cs/autoquest/tasktrees/treeimpl/TaskTreeImplTest.java	(revision 1132)
+++ 	(revision )
@@ -1,480 +1,0 @@
-//   Copyright 2012 Georg-August-Universität Göttingen, Germany
-//
-//   Licensed under the Apache License, Version 2.0 (the "License");
-//   you may not use this file except in compliance with the License.
-//   You may obtain a copy of the License at
-//
-//       http://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-package de.ugoe.cs.autoquest.tasktrees.treeimpl;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Test;
-
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.IIteration;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ISelection;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTree;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeBuilder;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNode;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeFactory;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskTreeNodeInfo;
-import de.ugoe.cs.autoquest.tasktrees.treeimpl.NodeInfo;
-import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeBuilder;
-import de.ugoe.cs.autoquest.tasktrees.treeimpl.TaskTreeNodeFactory;
-import de.ugoe.cs.autoquest.test.DummyGUIElement;
-import de.ugoe.cs.autoquest.test.DummyInteraction;
-
-/**
- * TODO comment
- * 
- * @version $Revision: $ $Date: 02.04.2012$
- * @author 2012, last modified by $Author: patrick$
- */
-public class TaskTreeImplTest {
-    
-    /** */
-    private static final int MAX_TREE_DEPTH = 15;
-
-    /** */
-    private ITaskTreeBuilder taskTreeBuilder = new TaskTreeBuilder();
-
-    /** */
-    private ITaskTreeNodeFactory taskTreeNodeFactory = new TaskTreeNodeFactory();
-
-    /**
-     * @throws Exception
-     * 
-     */
-    @Test
-    public void testRandomTrees() throws Exception {
-        int noOfTrees = 10;
-        int noOfMaxChildren = 8;
-        int maxDepth = MAX_TREE_DEPTH;
-
-        for (int i = 0; i < noOfTrees; i++) {
-            System.err.println("iteration " + (i + 1) + ":");
-            System.err.println("  creating tree");
-            Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos =
-                new HashMap<ITaskTreeNode, ITaskTreeNodeInfo>();
-            ITaskTreeNode rootNode = createTree(noOfMaxChildren, maxDepth, treeInfos);
-            System.err.println("  creating task tree");
-            ITaskTree taskTree = taskTreeNodeFactory.createTaskTree(rootNode);
-
-            System.err.println("  validating task tree");
-            assertEquals(rootNode, taskTree.getRoot());
-            assertMapsEqual(treeInfos, taskTree.getTaskMap());
-        }
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @param taskMap
-     */
-    private void assertMapsEqual(Map<ITaskTreeNode, ITaskTreeNodeInfo> map1,
-                                 Map<ITaskTreeNode, ITaskTreeNodeInfo> map2)
-    {
-        try {
-            if (map1 == null) {
-                assertNull(map2);
-                return;
-            }
-
-            assertEquals(map1.size(), map2.size());
-
-            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : map1.entrySet()) {
-                ITaskTreeNodeInfo value2 = map2.get(entry.getKey());
-                assertNotNull(value2);
-                assertEquals(entry.getValue().getTask(), value2.getTask());
-                //assertEquals(entry.getValue().getNoOfOccurencesInTree(),
-                //             value2.getNoOfOccurencesInTree());
-            }
-        }
-        catch (AssertionError e) {
-            dumpMap(map1);
-            dumpMap(map2);
-            throw e;
-        }
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param map2
-     */
-    private void dumpMap(Map<ITaskTreeNode, ITaskTreeNodeInfo> map) {
-        System.err.println();
-
-        if (map == null) {
-            System.err.println("map is null");
-        }
-        else {
-            System.err.println("map:");
-            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : map.entrySet()) {
-                System.err.print("  ");
-                System.err.print(entry.getKey());
-                for (int i = entry.getKey().toString().length(); i < 49; i++) {
-                    System.err.print(" ");
-                }
-                System.err.print(" : ");
-                System.err.println(entry.getValue());
-            }
-        }
-
-        System.err.println();
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param noOfMaxChildren
-     * @param maxDepth
-     * @param treeInfos
-     * @return
-     */
-    private ITaskTreeNode createTree(int                                   maxNoOfChildren,
-                                     int                                   maxDepth,
-                                     Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        /*
-         * for (int i = 0; i < (MAX_TREE_DEPTH + 1 - maxDepth); i++) { System.err.print("  "); }
-         */
-
-        ITaskTreeNode tree;
-
-        // integrating the maximum depth here assures, that either something between 0 and 8 will
-        // be the type, or if the max depth decreases near 0 only event tasks will be created
-        // to finish the tree creation
-        int type = (int) (Math.random() * (Math.min(8, maxDepth)));
-
-        switch (type)
-        {
-            case 0: {
-                // System.err.print("creating new event task ");
-                tree = createNewEventTask(treeInfos);
-                break;
-            }
-            case 1: {
-                // System.err.print("reusing event task ");
-                tree = reuseEventTask(treeInfos);
-                break;
-            }
-            case 2: {
-                // System.err.println("creating new sequence {");
-                tree = createNewSequence(maxNoOfChildren, maxDepth, treeInfos);
-                break;
-            }
-            case 3: {
-                // System.err.println("reusing sequence {");
-                tree = reuseSequence(maxNoOfChildren, maxDepth, treeInfos);
-                break;
-            }
-            case 4: {
-                // System.err.println("creating new selection {");
-                tree = createNewSelection(maxNoOfChildren, maxDepth, treeInfos);
-                break;
-            }
-            case 5: {
-                // System.err.println("reusing selection {");
-                tree = reuseSelection(maxNoOfChildren, maxDepth, treeInfos);
-                break;
-            }
-            case 6: {
-                // System.err.println("creating new iteration {");
-                tree = createNewIteration(maxNoOfChildren, maxDepth, treeInfos);
-                break;
-            }
-            case 7: {
-                // System.err.println("reusing iteration {");
-                tree = reuseIteration(maxNoOfChildren, maxDepth, treeInfos);
-                break;
-            }
-            default: {
-                // System.err.print("creating new event task per default ");
-                tree = createNewEventTask(treeInfos);
-            }
-        }
-
-        /*
-         * if (!(tree instanceof InteractionTask)) { for (int i = 0; i < (MAX_TREE_DEPTH + 1 -
-         * maxDepth); i++) { System.err.print("  "); }
-         * 
-         * System.err.print("} "); }
-         * 
-         * System.err.println(tree);
-         */
-
-        return tree;
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private IEventTask createNewEventTask(Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        Thread.sleep(2);
-        long id = System.currentTimeMillis();
-        IEventTask task =
-            taskTreeNodeFactory.createNewEventTask(new DummyInteraction("interaction" + id, 1),
-                                                   new DummyGUIElement("elem" + id));
-
-        treeInfos.put(task, new NodeInfo(task));
-
-        return task;
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private IEventTask reuseEventTask(Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        int noOfEventTasks = 0;
-
-        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-            if (entry.getKey() instanceof IEventTask) {
-                noOfEventTasks++;
-            }
-        }
-
-        if (noOfEventTasks > 0) {
-            noOfEventTasks = (int) (Math.random() * noOfEventTasks);
-
-            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-                if (entry.getKey() instanceof IEventTask) {
-                    if (--noOfEventTasks <= 0) {
-                        return (IEventTask) entry.getKey();
-                    }
-                }
-            }
-        }
-        else {
-            return createNewEventTask(treeInfos);
-        }
-
-        throw new RuntimeException("this is an implementation error");
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private ISequence createNewSequence(int                                   maxNoOfChildren,
-                                        int                                   maxDepth,
-                                        Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        ISequence sequence = taskTreeNodeFactory.createNewSequence();
-
-        int noOfChildren = (int) (Math.random() * maxNoOfChildren);
-
-        for (int i = 0; i < noOfChildren; i++) {
-            ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
-
-            // through first removing an existing parent it is assured, that a parent is recorded
-            // only once. This is needed, because parent may be reused in a tree as well, but we
-            // always
-            // iterate the whole tree
-            ((NodeInfo) treeInfos.get(child)).removeParent(sequence);
-            ((NodeInfo) treeInfos.get(child)).addParent(sequence);
-            taskTreeBuilder.addChild(sequence, child);
-        }
-
-        treeInfos.put(sequence, new NodeInfo(sequence));
-        return sequence;
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private ISequence reuseSequence(int                                   maxNoOfChildren,
-                                    int                                   maxDepth,
-                                    Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        int noOfSequences = 0;
-
-        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-            if (entry.getKey() instanceof ISequence) {
-                noOfSequences++;
-            }
-        }
-
-        if (noOfSequences > 0) {
-            noOfSequences = (int) (Math.random() * noOfSequences);
-
-            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-                if (entry.getKey() instanceof ISequence) {
-                    if (--noOfSequences <= 0) {
-                        return (ISequence) entry.getKey();
-                    }
-                }
-            }
-        }
-        else {
-            return createNewSequence(maxNoOfChildren, maxDepth, treeInfos);
-        }
-
-        throw new RuntimeException("this is an implementation error");
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private ISelection createNewSelection(int                                   maxNoOfChildren,
-                                          int                                   maxDepth,
-                                          Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        ISelection selection = taskTreeNodeFactory.createNewSelection();
-
-        int noOfChildren = (int) (Math.random() * maxNoOfChildren);
-
-        for (int i = 0; i < noOfChildren; i++) {
-            ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
-
-            // through first removing an existing parent it is assured, that a parent is recorded
-            // only once. This is needed, because parent may be reused in a tree as well, but we
-            // always
-            // iterate the whole tree
-            ((NodeInfo) treeInfos.get(child)).removeParent(selection);
-            ((NodeInfo) treeInfos.get(child)).addParent(selection);
-            taskTreeBuilder.addChild(selection, child);
-        }
-
-        treeInfos.put(selection, new NodeInfo(selection));
-        return selection;
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private ISelection reuseSelection(int                                   maxNoOfChildren,
-                                      int                                   maxDepth,
-                                      Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        int noOfSelections = 0;
-
-        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-            if (entry.getKey() instanceof ISelection) {
-                noOfSelections++;
-            }
-        }
-
-        if (noOfSelections > 0) {
-            noOfSelections = (int) (Math.random() * noOfSelections);
-
-            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-                if (entry.getKey() instanceof ISelection) {
-                    if (--noOfSelections <= 0) {
-                        return (ISelection) entry.getKey();
-                    }
-                }
-            }
-        }
-        else {
-            return createNewSelection(maxNoOfChildren, maxDepth, treeInfos);
-        }
-
-        throw new RuntimeException("this is an implementation error");
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private IIteration createNewIteration(int                                   maxNoOfChildren,
-                                          int                                   maxDepth,
-                                          Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        IIteration iteration = taskTreeNodeFactory.createNewIteration();
-
-        ITaskTreeNode child = createTree(maxNoOfChildren, maxDepth - 1, treeInfos);
-
-        // through first removing an existing parent it is assured, that a parent is recorded
-        // only once. This is needed, because parent may be reused in a tree as well, but we always
-        // iterate the whole tree
-        ((NodeInfo) treeInfos.get(child)).removeParent(iteration);
-        ((NodeInfo) treeInfos.get(child)).addParent(iteration);
-        taskTreeBuilder.setChild(iteration, child);
-
-        treeInfos.put(iteration, new NodeInfo(iteration));
-        return iteration;
-    }
-
-    /**
-     * TODO: comment
-     * 
-     * @param treeInfos
-     * @return
-     */
-    private IIteration reuseIteration(int                                   maxNoOfChildren,
-                                      int                                   maxDepth,
-                                      Map<ITaskTreeNode, ITaskTreeNodeInfo> treeInfos)
-        throws Exception
-    {
-        int noOfIterations = 0;
-
-        for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-            if (entry.getKey() instanceof IIteration) {
-                noOfIterations++;
-            }
-        }
-
-        if (noOfIterations > 0) {
-            noOfIterations = (int) (Math.random() * noOfIterations);
-
-            for (Map.Entry<ITaskTreeNode, ITaskTreeNodeInfo> entry : treeInfos.entrySet()) {
-                if (entry.getKey() instanceof IIteration) {
-                    if (--noOfIterations <= 0) {
-                        return (IIteration) entry.getKey();
-                    }
-                }
-            }
-        }
-        else {
-            return createNewIteration(maxNoOfChildren, maxDepth, treeInfos);
-        }
-
-        throw new RuntimeException("this is an implementation error");
-    }
-
-}
