132410 [CheatSheet] Resetting a task should also reset all dependentsv20060403

4 files changed, 360 insertions, 2 deletions

diff --git a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/AllCompositeTests.java b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/AllCompositeTests.java
index ea909d6ef..0b78f79a7 100644
--- a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/AllCompositeTests.java
+++ b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/AllCompositeTests.java
@@ -23,9 +23,10 @@ public class AllCompositeTests {
 		suite.addTestSuite(TestCompositeParser.class);
 		suite.addTestSuite(TestState.class);
 		suite.addTestSuite(TestTaskGroups.class);
-		suite.addTestSuite(TestEventing.class);
 		suite.addTestSuite(TestPersistence.class);
 		suite.addTestSuite(TestMarkupParser.class);
+		suite.addTestSuite(TestCheatSheetManagerEvents.class);
+		suite.addTestSuite(TestTaskEvents.class);
 		suite.addTestSuite(TestDependency.class);
 		//$JUnit-END$
 		return suite;
diff --git a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestEventing.java b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestCheatSheetManagerEvents.java
index c09e2bdb1..1946dd577 100644
--- a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestEventing.java
+++ b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestCheatSheetManagerEvents.java
@@ -18,7 +18,7 @@ import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
 
 import junit.framework.TestCase;
 
-public class TestEventing extends TestCase {
+public class TestCheatSheetManagerEvents extends TestCase {
 	
 	private CheatSheetElement element;
 	private CheatSheetManager manager;
diff --git a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestState.java b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestState.java
index 4ef14ec9b..99bdcf5da 100644
--- a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestState.java
+++ b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestState.java
@@ -145,5 +145,49 @@ public class TestState extends TestCase {
 		assertEquals(task4, TaskStateUtilities.getRestartTasks(group)[0]);
 		assertEquals(3, TaskStateUtilities.getRestartTasks(root).length);
 	}
+	
+	/**
+	 * Test that resetting a task resets dependents and their children also
+	 */
+	public void testResetDependents() {
+		TaskGroup root = new TaskGroup(model, "root", "rname", ITaskGroup.SET);
+		TaskGroup group = new TaskGroup(model, "group1", "gname", ITaskGroup.SET);
+		TaskGroup subGroup = new TaskGroup(model, "group2", "gname2", ITaskGroup.SET);
+		EditableTask task1 = new EditableTask(model, "id1", "name1", "ua.junit");
+		EditableTask task2 = new EditableTask(model, "id2", "name2", "ua.junit");
+		EditableTask task3 = new EditableTask(model, "id3", "name3", "ua.junit");
+		EditableTask task4 = new EditableTask(model, "id4", "name4", "ua.junit");
+		EditableTask task5 = new EditableTask(model, "id5", "name5", "ua.junit");
+		task2.addRequiredTask(task1);
+		task3.addRequiredTask(task2);
+		subGroup.addRequiredTask(task3);
+		task4.addRequiredTask(subGroup);
+		root.addSubtask(group);
+		group.addSubtask(task1);
+		group.addSubtask(task2);
+		group.addSubtask(task3);
+		group.addSubtask(subGroup);
+		group.addSubtask(task4);
+		subGroup.addSubtask(task5);
+		task1.complete();
+		task2.complete();
+		task3.complete();
+		task5.setStarted();
+		assertEquals(4, TaskStateUtilities.getRestartTasks(root).length);
+		assertEquals(4, TaskStateUtilities.getRestartTasks(task1).length);
+		assertEquals(3, TaskStateUtilities.getRestartTasks(task2).length);
+		assertEquals(2, TaskStateUtilities.getRestartTasks(task3).length);
+		assertEquals(1, TaskStateUtilities.getRestartTasks(subGroup).length);
+		// Reset task5 and  start task 1 and 3 and skip task 2.
+		// Resetting task1 will not require task2 or task3 to be reset
+		task5.setState(ICompositeCheatSheetTask.NOT_STARTED);
+		task3.setState(ICompositeCheatSheetTask.NOT_STARTED);
+		task2.setState(ICompositeCheatSheetTask.NOT_STARTED);
+		task2.setState(ICompositeCheatSheetTask.SKIPPED);
+		task3.setStarted();
+		assertEquals(3, TaskStateUtilities.getRestartTasks(root).length);
+		assertEquals(1, TaskStateUtilities.getRestartTasks(task1).length);
+		assertEquals(2, TaskStateUtilities.getRestartTasks(task2).length);
+	}
 
 }
diff --git a/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestTaskEvents.java b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestTaskEvents.java
new file mode 100644
index 000000000..eb8b4deae
--- /dev/null
+++ b/org.eclipse.ua.tests/cheatsheet/org/eclipse/ua/tests/cheatsheet/composite/TestTaskEvents.java
@@ -0,0 +1,313 @@
+/*******************************************************************************
+ * Copyright (c) 2006 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.ua.tests.cheatsheet.composite;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Observable;
+import java.util.Observer;
+
+import junit.framework.TestCase;
+
+import org.eclipse.ui.internal.cheatsheets.composite.model.CompositeCheatSheetModel;
+import org.eclipse.ui.internal.cheatsheets.composite.model.EditableTask;
+import org.eclipse.ui.internal.cheatsheets.composite.model.TaskGroup;
+import org.eclipse.ui.internal.provisional.cheatsheets.ICompositeCheatSheetTask;
+import org.eclipse.ui.internal.provisional.cheatsheets.ITaskGroup;
+
+/**
+ * Test for the events that get generated when the state of a task changes.
+ * These all use the same model. For reset events we don't count the number of
+ * events sent since the algorithm used to determine the impacted tasks will 
+ * add tasks to the list if there is uncertainty about whether it has become 
+ * unblocked. 
+ */
+
+public class TestTaskEvents extends TestCase {
+	
+	public class TaskMap {
+		
+		private Map map = new HashMap();
+		private int eventCount = 0;
+
+		public void put(ICompositeCheatSheetTask task) {
+			final String id = task.getId();
+			if (map.containsKey(id)) {
+				((TaskCounter)map.get(id)).incrementCount();
+			} else {
+				map.put(id, new TaskCounter());
+			}
+			eventCount++;
+		}
+		
+		public int getEventCount(ICompositeCheatSheetTask task) {
+			final String id = task.getId();
+			if (map.containsKey(id)) {
+				 return ((TaskCounter)map.get(id)).getCount();
+			} else {
+				return 0;
+			}
+		}
+		
+		public int getTotalEventCount() {
+			return eventCount ;
+		}
+	}
+	
+	public class TaskCounter {
+		private int count = 1;
+		
+		public int getCount() {
+			return count;
+		}
+		
+		public void incrementCount() {
+			count++;
+		}
+	}
+	
+	public class ModelObserver implements Observer {
+		public void update(Observable o, Object arg) {
+			taskMap.put((ICompositeCheatSheetTask)arg);
+		}
+	}
+
+	private CompositeCheatSheetModel model;
+	private TaskGroup rootTask;
+	private TaskGroup group1;
+	private TaskGroup group2;
+	private EditableTask task1A;
+	private EditableTask task1B;
+	private EditableTask task1C;
+	private EditableTask task2A;
+	private EditableTask task2B;
+	private EditableTask task3A;
+	private TaskMap taskMap;
+
+	private static final int IN_PROGRESS = ICompositeCheatSheetTask.IN_PROGRESS;
+	private static final int COMPLETED = ICompositeCheatSheetTask.COMPLETED;
+	private static final int SKIPPED = ICompositeCheatSheetTask.SKIPPED;
+	
+	/**
+	 * Initialize a composite cheatsheet with one root taskGroup, two sub groups and 
+	 * three tasks in each group
+	 */	
+	protected void createModel(String rootKind, String group1Kind, String group2Kind)  {
+		model = new CompositeCheatSheetModel("name", "description", "explorerId");
+		rootTask = new TaskGroup(model, "root", "name", rootKind);
+		group1 = new TaskGroup(model, "group1", "group1", group1Kind);
+		group2 = new TaskGroup(model, "group2", "group2", group1Kind);
+		task1A = new EditableTask(model, "task1A", "name", "kind");
+		task1B = new EditableTask(model, "task1B", "name", "kind");
+		task1C = new EditableTask(model, "task1C", "name", "kind");
+		task2A = new EditableTask(model, "task2A", "name", "kind");
+		task2B = new EditableTask(model, "task2B", "name", "kind");
+		task3A = new EditableTask(model, "task3A", "name", "kind");
+		model.setRootTask(rootTask);
+		rootTask.addSubtask(group1);	
+		rootTask.addSubtask(group2);	
+		rootTask.addSubtask(task3A);	
+		group1.addSubtask(task1A);
+		group1.addSubtask(task1B);
+		group1.addSubtask(task1C);	
+		group2.addSubtask(task2A);
+		group2.addSubtask(task2B);
+	}
+	
+	protected void setUp() throws Exception {
+		resetTaskMap();
+	}
+
+	private void resetTaskMap() {
+		taskMap = new TaskMap();
+	}
+
+	public void testStartTask() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(IN_PROGRESS);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(3, taskMap.getTotalEventCount());
+	}
+
+	public void testStartTwoTasks() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(IN_PROGRESS);
+		task1B.setState(IN_PROGRESS);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(4, taskMap.getTotalEventCount());
+	}
+	
+	public void testCompleteTaskGroup() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		task1B.setState(COMPLETED);
+		task1C.setState(COMPLETED);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(task1C));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(2, taskMap.getEventCount(group1));
+		assertEquals(6, taskMap.getTotalEventCount());
+	}
+
+	public void testCompleteTaskWithDependent() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		task1B.addRequiredTask(task1A);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(4, taskMap.getTotalEventCount());
+	}
+
+	public void testResetSingleTask() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		task1B.setState(COMPLETED);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{task1A});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getTotalEventCount());
+	}
+	
+	public void testResetTaskWithDependent() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1B.addRequiredTask(task1A);
+		task1A.setState(COMPLETED);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{task1A});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+	}
+
+	public void testResetSingleTaskInCompleteSet() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		task1B.setState(COMPLETED);
+		task1C.setState(COMPLETED);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{task1A});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(2, taskMap.getTotalEventCount());
+	}
+
+	public void testResetTwoTasksInCompleteSet() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		task1B.setState(COMPLETED);
+		task1C.setState(COMPLETED);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{task1A, task1B});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(3, taskMap.getTotalEventCount());
+	}
+	
+	public void testResetAllTasksInCompleteSet() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		task1B.setState(COMPLETED);
+		task1C.setState(COMPLETED);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{task1A, task1B, task1C});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(task1C));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+	}
+	
+	public void testResetSingleTaskInCompleteChoice() {
+		createModel(ITaskGroup.SET, ITaskGroup.CHOICE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{task1A});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(task1C));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+	}
+	
+	public void testResetGroupWithTwoStartedTasks() {
+		createModel(ITaskGroup.SET, ITaskGroup.SEQUENCE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		task1B.setState(COMPLETED);
+		task3A.setState(IN_PROGRESS);
+		resetTaskMap();
+		model.resetTasks(new ICompositeCheatSheetTask[]{group1});
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(4, taskMap.getTotalEventCount());
+    }
+	
+	public void testCompleteChoice() {
+		createModel(ITaskGroup.SET, ITaskGroup.CHOICE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(task1C));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(5, taskMap.getTotalEventCount());
+	}
+	
+	public void testCompleteGroupWithDependentGroup() {
+		createModel(ITaskGroup.SET, ITaskGroup.CHOICE, ITaskGroup.CHOICE);
+		group2.addRequiredTask(group1);
+		model.addObserver(new ModelObserver());
+		task1A.setState(COMPLETED);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(task1C));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(1, taskMap.getEventCount(task2A));
+		assertEquals(1, taskMap.getEventCount(task2B));
+		assertEquals(1, taskMap.getEventCount(group2));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(8, taskMap.getTotalEventCount());
+	}
+	
+	public void testSkipTaskGroup() {
+		createModel(ITaskGroup.SET, ITaskGroup.CHOICE, ITaskGroup.CHOICE);
+		model.addObserver(new ModelObserver());
+		group1.setState(SKIPPED);
+		assertEquals(1, taskMap.getEventCount(task1A));
+		assertEquals(1, taskMap.getEventCount(task1B));
+		assertEquals(1, taskMap.getEventCount(task1C));
+		assertEquals(1, taskMap.getEventCount(group1));
+		assertEquals(1, taskMap.getEventCount(rootTask));
+		assertEquals(5, taskMap.getTotalEventCount());
+	}
+
+}