NEW - bug 160389: [api] change how offline task data is cached to disk and refactor attribute factory

https://bugs.eclipse.org/bugs/show_bug.cgi?id=160389

6 files changed, 562 insertions, 168 deletions

diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java
index f89a80efe..034e63152 100644
--- a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java
@@ -50,6 +50,8 @@ public class AllTasksTests {
 		suite.addTestSuite(TaskHistoryTest.class);
 		suite.addTestSuite(UrlConnectionUtilTest.class);
 		suite.addTestSuite(CommentQuoterTest.class);
+		suite.addTestSuite(OfflineStorageTest.class);
+		suite.addTestSuite(OfflineCachingStorageTest.class);
 		// $JUnit-END$
 		
 		// suite.addTestSuite(BackgroundSaveTest.class);
diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/OfflineCachingStorageTest.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/OfflineCachingStorageTest.java
new file mode 100644
index 000000000..5a09b31a3
--- /dev/null
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/OfflineCachingStorageTest.java
@@ -0,0 +1,149 @@
+/*******************************************************************************
+ * Copyright (c) 2004 - 2006 Mylar committers 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
+ *******************************************************************************/
+
+package org.eclipse.mylyn.tasks.tests;
+
+import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.eclipse.mylyn.internal.tasks.core.TaskDataState;
+import org.eclipse.mylyn.internal.tasks.ui.OfflineCachingStorage;
+import org.eclipse.mylyn.internal.tasks.ui.OfflineFileStorage;
+import org.eclipse.mylyn.tasks.core.RepositoryTaskAttribute;
+import org.eclipse.mylyn.tasks.core.RepositoryTaskData;
+import org.eclipse.mylyn.tasks.tests.connector.MockAttributeFactory;
+import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
+import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
+
+/**
+ * @author Rob Elves
+ */
+public class OfflineCachingStorageTest extends TestCase {
+
+	private static final String MOCK_ID = "1";
+
+	private File dataDir;
+
+	private OfflineCachingStorage storage;
+
+	protected void setUp() throws Exception {
+		//dataDir = new File("c:/offline");
+		dataDir = new File(TasksUiPlugin.getDefault().getDataDirectory() + '/' + "offline");
+		storage = new OfflineCachingStorage(new OfflineFileStorage(dataDir));
+		storage.start();
+		super.setUp();
+	}
+
+	protected void tearDown() throws Exception {
+		storage.stop();
+		storage.clear();
+	}
+
+	public void testPutAndGet() throws Exception {
+
+		TaskDataState state = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+
+		RepositoryTaskData newData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+
+		newData.setAttributeValue("attributeKey1", "attValue!");
+		newData.setDescription("description");
+		newData.setNew(true);
+		newData.setNewComment("new comment");
+		newData.setSummary("summary");
+		newData.setTaskKey("task key");
+
+		RepositoryTaskData oldData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+
+		Set<RepositoryTaskAttribute> edits = new HashSet<RepositoryTaskAttribute>();
+
+		state.setNewTaskData(newData);
+		state.setOldTaskData(oldData);
+		state.setEdits(edits);
+
+		storage.put(state);
+
+		TaskDataState retrieved = storage.get(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+		assertNotNull(retrieved);
+		RepositoryTaskData newTaskData = retrieved.getNewTaskData();
+		assertNotNull(newTaskData);
+		assertEquals(MockRepositoryConnector.REPOSITORY_KIND, newTaskData.getRepositoryKind());
+		assertEquals("description", newTaskData.getDescription());
+		assertEquals("new comment", newTaskData.getNewComment());
+		assertEquals("task key", newTaskData.getTaskKey());
+	}
+
+	public void testRemove() throws Exception {
+		assertNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID));
+
+		TaskDataState state = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+
+		RepositoryTaskData newData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+
+		newData.setAttributeValue("attributeKey1", "attValue!");
+		newData.setDescription("description");
+		newData.setNew(true);
+		newData.setNewComment("new comment");
+		newData.setSummary("summary");
+		newData.setTaskKey("task key");
+
+		RepositoryTaskData oldData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+
+		Set<RepositoryTaskAttribute> edits = new HashSet<RepositoryTaskAttribute>();
+
+		state.setNewTaskData(newData);
+		state.setOldTaskData(oldData);
+		state.setEdits(edits);
+
+		storage.put(state);
+		assertEquals(1, storage.getReadQueue().size());
+		assertEquals("1", storage.getReadQueue().iterator().next().getId());
+		assertNotNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID));
+		storage.remove(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+		assertEquals(0, storage.getReadQueue().size());
+		assertNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID));
+
+	}
+
+	public void testLRUQueue() {
+		assertNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID));
+		assertEquals(0, storage.getReadQueue().size());
+		TaskDataState state1 = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID);
+		TaskDataState state2 = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, "2");
+		TaskDataState state3 = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, "3");
+
+		storage.put(state1);
+		storage.put(state2);
+		storage.put(state3);
+
+		assertEquals(3, storage.getReadQueue().size());
+
+		// should return least recently used
+		assertEquals("1", storage.getReadQueue().iterator().next().getId());
+
+		assertNotNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, "3"));
+		assertNotNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, "2"));
+		assertNotNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, MOCK_ID));
+
+		assertEquals(3, storage.getReadQueue().size());
+
+		// should return least recently used
+		assertEquals("3", storage.getReadQueue().iterator().next().getId());
+		storage.put(state1);
+		storage.put(state3);
+		// should return least recently used
+		assertEquals("2", storage.getReadQueue().iterator().next().getId());
+		assertEquals(3, storage.getReadQueue().size());
+	}
+}
diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/OfflineStorageTest.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/OfflineStorageTest.java
new file mode 100644
index 000000000..2f5ed7545
--- /dev/null
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/OfflineStorageTest.java
@@ -0,0 +1,308 @@
+/*******************************************************************************
+ * Copyright (c) 2004 - 2006 Mylar committers 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
+ *******************************************************************************/
+
+package org.eclipse.mylyn.tasks.tests;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.eclipse.mylyn.internal.tasks.core.TaskDataState;
+import org.eclipse.mylyn.internal.tasks.ui.OfflineFileStorage;
+import org.eclipse.mylyn.tasks.core.RepositoryAttachment;
+import org.eclipse.mylyn.tasks.core.RepositoryOperation;
+import org.eclipse.mylyn.tasks.core.RepositoryTaskAttribute;
+import org.eclipse.mylyn.tasks.core.RepositoryTaskData;
+import org.eclipse.mylyn.tasks.core.TaskComment;
+import org.eclipse.mylyn.tasks.tests.connector.MockAttributeFactory;
+import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
+import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
+import org.eclipse.ui.XMLMemento;
+
+/**
+ * @author Rob Elves
+ */
+public class OfflineStorageTest extends TestCase {
+	
+	File dataDir;
+
+	OfflineFileStorage storage;
+
+	protected void setUp() throws Exception {
+		//dataDir = new File("c:/offline");
+		dataDir = new File(TasksUiPlugin.getDefault().getDataDirectory() + "/offline");
+		storage = new OfflineFileStorage(dataDir);
+		storage.start();
+		super.setUp();
+	}
+
+	protected void tearDown() throws Exception {
+		storage.stop();
+		removeTestFiles(dataDir);
+	}
+
+	private void removeTestFiles(File folder) {
+		if (folder.isDirectory()) {
+			for (File file : folder.listFiles()) {
+				removeTestFiles(file);
+			}
+		}
+		folder.delete();
+	}
+
+	public void testPutAndGet() throws Exception {
+
+		TaskDataState state = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, "1");
+
+		RepositoryTaskData newData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
+
+		newData.setAttributeValue("attributeKey1", "attValue!");
+		newData.setDescription("description");
+		newData.setNew(true);
+		newData.setNewComment("new comment");
+		newData.setSummary("summary");
+		newData.setTaskKey("task key");
+
+		RepositoryTaskData oldData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
+
+		Set<RepositoryTaskAttribute> edits = new HashSet<RepositoryTaskAttribute>();
+
+		state.setNewTaskData(newData);
+		state.setOldTaskData(oldData);
+		state.setEdits(edits);
+
+		storage.put(state);
+
+		TaskDataState retrieved = storage.get(MockRepositoryConnector.REPOSITORY_URL, "1");
+		assertNotNull(retrieved);
+		RepositoryTaskData newTaskData = retrieved.getNewTaskData();
+		assertNotNull(newTaskData);
+		assertEquals(MockRepositoryConnector.REPOSITORY_KIND, newTaskData.getRepositoryKind());
+		assertEquals("description", newTaskData.getDescription());
+		assertEquals("new comment", newTaskData.getNewComment());
+		assertEquals("task key", newTaskData.getTaskKey());
+	}
+
+	public void testRemove() throws Exception {
+		assertNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, "1"));
+
+		TaskDataState state = new TaskDataState(MockRepositoryConnector.REPOSITORY_URL, "1");
+
+		RepositoryTaskData newData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
+
+		newData.setAttributeValue("attributeKey1", "attValue!");
+		newData.setDescription("description");
+		newData.setNew(true);
+		newData.setNewComment("new comment");
+		newData.setSummary("summary");
+		newData.setTaskKey("task key");
+
+		RepositoryTaskData oldData = new RepositoryTaskData(new MockAttributeFactory(),
+				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
+
+		Set<RepositoryTaskAttribute> edits = new HashSet<RepositoryTaskAttribute>();
+
+		state.setNewTaskData(newData);
+		state.setOldTaskData(oldData);
+		state.setEdits(edits);
+
+		storage.put(state);
+		assertNotNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, "1"));
+		storage.remove(MockRepositoryConnector.REPOSITORY_URL, "1");
+		assertNull(storage.get(MockRepositoryConnector.REPOSITORY_URL, "1"));
+
+	}
+
+	public void testAttributes() throws Exception {
+		List<RepositoryTaskAttribute> attributes = new ArrayList<RepositoryTaskAttribute>();
+		RepositoryTaskAttribute attribute = new RepositoryTaskAttribute("testId", "testName", true);
+		attribute.setReadOnly(true);
+		attribute.addOption("Option Name 1", "Option Value 1");
+		attribute.addOption("Option Name 2", "Option Value 2");
+		attribute.addValue("Value 1");
+		attribute.addValue("Value 2");
+		attribute.addValue("Value 3");
+		attribute.putMetaDataValue("MetaKey1", "MetaValue1");
+		attribute.putMetaDataValue("MetaKey2", "MetaValue2");
+		attribute.putMetaDataValue("MetaKey3", "MetaValue3");
+		attribute.putMetaDataValue("MetaKey4", "MetaValue4");
+
+		attributes.add(attribute);
+
+		XMLMemento memento = XMLMemento.createWriteRoot("Attributes");
+		storage.addAttributes(memento, attributes);
+		List<RepositoryTaskAttribute> readAttributes = storage.readAttributes(memento);
+		assertNotNull(readAttributes);
+		assertEquals(1, readAttributes.size());
+		RepositoryTaskAttribute attr = readAttributes.get(0);
+
+		assertEquals("testId", attr.getId());
+		assertEquals("testName", attr.getName());
+		assertEquals(true, attr.isHidden());
+		assertEquals(true, attr.isReadOnly());
+
+		assertNotNull(attr.getOptions());
+		assertEquals(2, attr.getOptions().size());
+
+		assertEquals("Option Name 1", attr.getOptions().get(0));
+		assertEquals("Option Name 2", attr.getOptions().get(1));
+		assertEquals("Option Value 1", attr.getOptionParameter(attr.getOptions().get(0)));
+		assertEquals("Option Value 2", attr.getOptionParameter(attr.getOptions().get(1)));
+
+		assertEquals("Value 1", attr.getValues().get(0));
+		assertEquals("Value 2", attr.getValues().get(1));
+		assertEquals("Value 3", attr.getValues().get(2));
+
+		assertEquals("MetaValue1", attribute.getMetaDataValue("MetaKey1"));
+		assertEquals("MetaValue2", attribute.getMetaDataValue("MetaKey2"));
+		assertEquals("MetaValue3", attribute.getMetaDataValue("MetaKey3"));
+		assertEquals("MetaValue4", attribute.getMetaDataValue("MetaKey4"));
+	}
+
+	public void testOperations() throws Exception {
+		RepositoryOperation op = new RepositoryOperation("knob1", "operationName1");
+		op.setChecked(true);
+		op.setInputName("InputName");
+		op.setInputValue("InputValue");
+		op.setUpOptions("TheOptionName");
+		op.addOption("optionName1", "optionValue1");
+		op.addOption("optionName2", "optionValue2");
+		op.setOptionSelection("optionSelection1");
+
+		RepositoryOperation op2 = new RepositoryOperation("knob2", "operationName2");
+		op2.setChecked(true);
+		op2.setInputName("InputName2");
+		op2.setInputValue("InputValue2");
+		op2.setUpOptions("TheOptionName2");
+		op2.addOption("optionName1", "optionValue1");
+		op2.addOption("optionName2", "optionValue2");
+		op2.setOptionSelection("optionSelection2");
+		XMLMemento memento = XMLMemento.createWriteRoot("Operations");
+
+		List<RepositoryOperation> operations = new ArrayList<RepositoryOperation>();
+		operations.add(op);
+		operations.add(op2);
+		storage.addOperations(memento, operations);
+		List<RepositoryOperation> readOperations = storage.readOperations(memento);
+		RepositoryOperation op1 = readOperations.get(0);
+		assertEquals("knob1", op1.getKnobName());
+		assertEquals("operationName1", op1.getOperationName());
+		assertEquals("InputName", op1.getInputName());
+		assertEquals("InputValue", op1.getInputValue());
+
+		assertEquals("TheOptionName", op1.getOptionName());
+		assertEquals(2, op1.getOptionNames().size());
+		assertEquals("optionValue1", op1.getOptionValue(op1.getOptionNames().get(0)));
+		assertEquals("optionValue2", op1.getOptionValue(op1.getOptionNames().get(1)));
+		assertEquals("optionSelection1", op1.getOptionSelection());
+
+		RepositoryOperation op2ver2 = readOperations.get(1);
+		assertEquals("knob2", op2ver2.getKnobName());
+		assertEquals("operationName2", op2ver2.getOperationName());
+		assertEquals("InputName2", op2ver2.getInputName());
+		assertEquals("InputValue2", op2ver2.getInputValue());
+
+		assertEquals("TheOptionName2", op2ver2.getOptionName());
+		assertEquals(2, op2ver2.getOptionNames().size());
+		assertEquals("optionValue1", op2ver2.getOptionValue(op1.getOptionNames().get(0)));
+		assertEquals("optionValue2", op2ver2.getOptionValue(op1.getOptionNames().get(1)));
+		assertEquals("optionSelection2", op2ver2.getOptionSelection());
+	}
+
+	public void testComments() throws Exception {
+		TaskComment comment1 = new TaskComment(new MockAttributeFactory(), 1);
+		comment1.setAttachmentId("attachmentId1");
+		comment1.setHasAttachment(true);
+		comment1.addAttribute("attr1", new RepositoryTaskAttribute("attr1", "attr1Name", false));
+
+		TaskComment comment2 = new TaskComment(new MockAttributeFactory(), 2);
+		comment2.setAttachmentId("attachmentId2");
+		comment2.setHasAttachment(false);
+		comment2.addAttribute("attr2", new RepositoryTaskAttribute("attr2", "attr2Name", false));
+		comment2.addAttribute("attr3", new RepositoryTaskAttribute("attr3", "attr3Name", true));
+
+		XMLMemento memento = XMLMemento.createWriteRoot("Comments");
+		List<TaskComment> comments = new ArrayList<TaskComment>();
+		comments.add(comment1);
+		comments.add(comment2);
+		storage.addComments(memento, comments);
+		List<TaskComment> returnedComments = storage.readComments(memento);
+		assertEquals(2, returnedComments.size());
+
+		assertEquals("attachmentId1", returnedComments.get(0).getAttachmentId());
+		assertEquals(true, returnedComments.get(0).hasAttachment());
+		assertEquals(1, returnedComments.get(0).getAttributes().size());
+		assertEquals("attr1", returnedComments.get(0).getAttributes().get(0).getId());
+		assertEquals("attr1Name", returnedComments.get(0).getAttributes().get(0).getName());
+
+		assertEquals("attachmentId2", returnedComments.get(1).getAttachmentId());
+		assertEquals(false, returnedComments.get(1).hasAttachment());
+		assertEquals(2, returnedComments.get(1).getAttributes().size());
+		assertEquals("attr2", returnedComments.get(1).getAttributes().get(0).getId());
+		assertEquals("attr2Name", returnedComments.get(1).getAttributes().get(0).getName());
+		assertEquals("attr3Name", returnedComments.get(1).getAttributes().get(1).getName());
+	}
+
+	public void testAttachments() throws Exception {
+
+		List<RepositoryAttachment> attachments = new ArrayList<RepositoryAttachment>();
+		RepositoryAttachment attachment1 = new RepositoryAttachment(new MockAttributeFactory());
+		attachment1.setCreator("thecreator");
+		attachment1.setObsolete(false);
+		attachment1.setPatch(true);
+		attachment1.setRepositoryKind("bugzilla");
+		attachment1.setRepositoryUrl("repUrl");
+		attachment1.setTaskId("taskid1");
+		attachment1.addAttribute("attr1", new RepositoryTaskAttribute("attr1", "attr1Name", true));
+		attachment1.addAttribute("attr2", new RepositoryTaskAttribute("attr2", "attr2Name", true));
+
+		RepositoryAttachment attachment2 = new RepositoryAttachment(new MockAttributeFactory());
+		attachment2.setCreator("thecreator2");
+		attachment2.setObsolete(true);
+		attachment2.setPatch(false);
+		attachment2.setRepositoryKind("bugzilla2");
+		attachment2.setRepositoryUrl("repUrl2");
+		attachment2.setTaskId("taskid2");
+		attachment2.addAttribute("attr3", new RepositoryTaskAttribute("attr3", "attr3Name", true));
+		attachment2.addAttribute("attr4", new RepositoryTaskAttribute("attr4", "attr4Name", true));
+
+		attachments.add(attachment1);
+		attachments.add(attachment2);
+		XMLMemento memento = XMLMemento.createWriteRoot("Attachments");
+		storage.addAttachments(memento, attachments);
+		List<RepositoryAttachment> readAttachments = storage.readAttachments(memento);
+
+		assertEquals(2, readAttachments.size());
+		RepositoryAttachment readAttachment = readAttachments.get(0);
+		assertEquals(attachment1.getTaskId(), readAttachment.getTaskId());
+		assertEquals(attachment1.getCreator(), readAttachment.getCreator());
+		assertEquals(attachment1.isObsolete(), readAttachment.isObsolete());
+		assertEquals(attachment1.isPatch(), readAttachment.isPatch());
+		assertEquals(attachment1.getRepositoryKind(), readAttachment.getRepositoryKind());
+		assertEquals(attachment1.getRepositoryUrl(), readAttachment.getRepositoryUrl());
+		assertEquals(attachment1.getAttributeValue("attr1"), readAttachment.getAttributeValue("attr1"));
+		assertEquals(attachment1.getAttributeValue("attr2"), readAttachment.getAttributeValue("attr2"));
+
+		readAttachment = readAttachments.get(1);
+		assertEquals(attachment2.getTaskId(), readAttachment.getTaskId());
+		assertEquals(attachment2.getCreator(), readAttachment.getCreator());
+		assertEquals(attachment2.isObsolete(), readAttachment.isObsolete());
+		assertEquals(attachment2.isPatch(), readAttachment.isPatch());
+		assertEquals(attachment2.getRepositoryKind(), readAttachment.getRepositoryKind());
+		assertEquals(attachment2.getRepositoryUrl(), readAttachment.getRepositoryUrl());
+		assertEquals(attachment2.getAttributeValue("attr3"), readAttachment.getAttributeValue("attr3"));
+		assertEquals(attachment2.getAttributeValue("attr4"), readAttachment.getAttributeValue("attr4"));
+	}
+}
diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/RepositoryTaskSynchronizationTest.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/RepositoryTaskSynchronizationTest.java
index 11438cf18..d40bbe199 100644
--- a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/RepositoryTaskSynchronizationTest.java
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/RepositoryTaskSynchronizationTest.java
@@ -39,9 +39,9 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 
 	private static final String DATE_STAMP_1 = "2006-06-21 15:29:40";
 
-	private static final String HANDLE1 = "handle1";
+	private static final String MOCCK_ID = "1";
 
-	private static final String URL1 = "http://www.eclipse.org/mylar";
+	//private static final String URL1 = "http://www.eclipse.org/mylar";
 
 	private TestRepositoryConnector connector = new TestRepositoryConnector();
 
@@ -61,9 +61,9 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 	}
 
 	public void testHasIncoming() {
-		AbstractTask task = new MockRepositoryTask(HANDLE1);
+		AbstractTask task = new MockRepositoryTask(MOCCK_ID);
 		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(), connector.getRepositoryType(),
-				URL1, "1");
+				MockRepositoryConnector.REPOSITORY_URL, MOCCK_ID);
 		task.setLastSyncDateStamp("never");
 
 		assertTrue(TasksUiPlugin.getSynchronizationManager().checkHasIncoming(task, taskData));
@@ -89,7 +89,7 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 		AbstractTask task = primeTaskAndRepository(RepositoryTaskSyncState.INCOMING,
 				RepositoryTaskSyncState.INCOMING);
 		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(
-				task.getHandleIdentifier());
+				task.getRepositoryUrl(), task.getTaskId());
 		assertEquals(DATE_STAMP_1, task.getLastSyncDateStamp());
 		assertEquals(RepositoryTaskSyncState.INCOMING, task.getSyncState());
 		assertEquals(DATE_STAMP_2, newData.getLastModified());
@@ -101,14 +101,14 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 		// and again...
 
 		RepositoryTaskData taskData3 = new RepositoryTaskData(new MockAttributeFactory(),
-				connector.getRepositoryType(), URL1, "1");
+				connector.getRepositoryType(), MockRepositoryConnector.REPOSITORY_URL, "1");
 		taskData3.setAttributeValue(RepositoryTaskAttribute.DATE_MODIFIED, DATE_STAMP_3);
 		TasksUiPlugin.getSynchronizationManager().saveIncoming(task, taskData3, false);
 		// last modified stamp not updated until user synchronizes (newdata ==
 		// olddata)
 		assertEquals(RepositoryTaskSyncState.INCOMING, task.getSyncState());
 		assertEquals(DATE_STAMP_1, task.getLastSyncDateStamp());
-		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getHandleIdentifier());
+		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
 		assertEquals(DATE_STAMP_3, taskData.getLastModified());
 
 		// Should keep INCOMING state state since new data has same date samp
@@ -116,7 +116,7 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 		TasksUiPlugin.getSynchronizationManager().saveIncoming(task, taskData3, false);
 		assertEquals(RepositoryTaskSyncState.INCOMING, task.getSyncState());
 		assertEquals(DATE_STAMP_1, task.getLastSyncDateStamp());
-		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getHandleIdentifier());
+		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
 		assertEquals(DATE_STAMP_3, taskData.getLastModified());
 	}
 
@@ -188,8 +188,7 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 		assertEquals(DATE_STAMP_1, task.getLastSyncDateStamp());
 		TasksUiPlugin.getSynchronizationManager().saveIncoming(task, newData, false);
 		assertEquals(RepositoryTaskSyncState.INCOMING, task.getSyncState());
-		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(
-				task.getHandleIdentifier());
+		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
 		assertEquals(DATE_STAMP_2, taskData.getLastModified());
 		// assertEquals(DATE_STAMP_2, task.getLastModifiedDateStamp());
 	}
@@ -212,8 +211,7 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 				RepositoryTaskSyncState.SYNCHRONIZED);
 		assertEquals(DATE_STAMP_1, task.getLastSyncDateStamp());
 
-		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(
-				task.getHandleIdentifier());
+		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(task.getRepositoryUrl(), task.getTaskId());
 
 		taskData.setNewComment("new comment");
 
@@ -231,12 +229,12 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 		TasksUiPlugin.getSynchronizationManager().saveIncoming(task, newData, true);
 		assertEquals(RepositoryTaskSyncState.CONFLICT, task.getSyncState());
 		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(
-				task.getHandleIdentifier());
+				task.getRepositoryUrl(), task.getTaskId());
 
 		assertEquals(DATE_STAMP_2, taskData.getLastModified());
 		TasksUiPlugin.getSynchronizationManager().saveIncoming(task, newData, true);
 		assertEquals(RepositoryTaskSyncState.CONFLICT, task.getSyncState());
-		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getHandleIdentifier());
+		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
 		assertEquals(DATE_STAMP_2, taskData.getLastModified());
 	}
 
@@ -258,14 +256,13 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 		// Forced
 		AbstractTask task = primeTaskAndRepository(RepositoryTaskSyncState.OUTGOING,
 				RepositoryTaskSyncState.INCOMING);
-		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(
-				task.getHandleIdentifier());
+		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
 
 		assertEquals(DATE_STAMP_1, task.getLastSyncDateStamp());
 		assertEquals(RepositoryTaskSyncState.OUTGOING, task.getSyncState());
 		TasksUiPlugin.getSynchronizationManager().saveIncoming(task, newData, true);
 		assertEquals(RepositoryTaskSyncState.CONFLICT, task.getSyncState());
-		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getHandleIdentifier());
+		taskData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(), task.getTaskId());
 
 		assertEquals(DATE_STAMP_2, taskData.getLastModified());
 		// assertEquals(DATE_STAMP_2, task.getLastModifiedDateStamp());
@@ -316,23 +313,21 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 				RepositoryTaskSyncState.SYNCHRONIZED);
 		RepositoryTaskData taskData1 = new RepositoryTaskData(new MockAttributeFactory(),
 				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(task.getHandleIdentifier(), taskData1);
-		taskData1 = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(task.getHandleIdentifier());
+		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(taskData1);
+		taskData1 = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(task.getRepositoryUrl(), task.getTaskId());
 
 		taskData1.setNewComment("Testing");
 		Set<RepositoryTaskAttribute> edits = new HashSet<RepositoryTaskAttribute>();
 		edits.add(taskData1.getAttribute(RepositoryTaskAttribute.COMMENT_NEW));
-		TasksUiPlugin.getDefault().getTaskDataManager().saveEdits(task.getHandleIdentifier(), edits);
+		TasksUiPlugin.getDefault().getTaskDataManager().saveEdits(task.getRepositoryUrl(), task.getTaskId(), edits);
 
-		RepositoryTaskData editedData = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(
-				task.getHandleIdentifier());
+		RepositoryTaskData editedData = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(task.getRepositoryUrl(), task.getTaskId());
 		assertEquals("Testing", editedData.getNewComment());
 
 		TasksUiPlugin.getSynchronizationManager().discardOutgoing(task);
 
 		assertTrue(task.getSyncState().equals(RepositoryTaskSyncState.SYNCHRONIZED));
-		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(
-				task.getHandleIdentifier());
+		RepositoryTaskData taskData = TasksUiPlugin.getDefault().getTaskDataManager().getEditableCopy(task.getRepositoryUrl(), task.getTaskId());
 		assertEquals("", taskData.getNewComment());
 
 	}
@@ -420,15 +415,14 @@ public class RepositoryTaskSynchronizationTest extends TestCase {
 	private AbstractTask primeTaskAndRepository(RepositoryTaskSyncState localState,
 			RepositoryTaskSyncState remoteState) {
 		RepositoryTaskData taskData = null;
-		AbstractTask task = new MockRepositoryTask(HANDLE1);
+		AbstractTask task = new MockRepositoryTask(MOCCK_ID);
 
-		taskData = new RepositoryTaskData(new MockAttributeFactory(), connector.getRepositoryType(), URL1, "1");
-		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(task.getHandleIdentifier(), taskData);
+		taskData = new RepositoryTaskData(new MockAttributeFactory(), connector.getRepositoryType(), MockRepositoryConnector.REPOSITORY_URL, MOCCK_ID);
 		taskData.setAttributeValue(RepositoryTaskAttribute.DATE_MODIFIED, DATE_STAMP_1);
 		task.setLastSyncDateStamp(DATE_STAMP_1);
 		task.setSyncState(localState);
-
-		newData = new RepositoryTaskData(new MockAttributeFactory(), connector.getRepositoryType(), URL1, "1");
+		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(taskData);
+		newData = new RepositoryTaskData(new MockAttributeFactory(), connector.getRepositoryType(), MockRepositoryConnector.REPOSITORY_URL, MOCCK_ID);
 
 		switch (remoteState) {
 		case CONFLICT:
diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskDataManagerTest.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskDataManagerTest.java
index 9908738e2..48908b968 100644
--- a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskDataManagerTest.java
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskDataManagerTest.java
@@ -9,14 +9,12 @@
 package org.eclipse.mylyn.tasks.tests;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Set;
 
 import junit.framework.TestCase;
 
 import org.eclipse.core.runtime.CoreException;
-import org.eclipse.mylyn.internal.tasks.core.RepositoryTaskHandleUtil;
 import org.eclipse.mylyn.internal.tasks.core.TaskDataManager;
 import org.eclipse.mylyn.tasks.core.RepositoryTaskAttribute;
 import org.eclipse.mylyn.tasks.core.RepositoryTaskData;
@@ -51,10 +49,8 @@ public class TaskDataManagerTest extends TestCase {
 	public void testAdd() throws CoreException {
 		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(),
 				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
+		offlineTaskDataManager.setNewTaskData(taskData);
+		assertNotNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1"));
 	}
 
 	public void testSave() throws CoreException, IOException, ClassNotFoundException {
@@ -66,13 +62,10 @@ public class TaskDataManagerTest extends TestCase {
 		attrib1.putMetaDataValue("key2", "value2");
 		taskData.addAttribute("key", attrib1);
 
-
 		assertNotNull(taskData.getAttribute("key"));
-		
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
-		
-		
+
+		offlineTaskDataManager.setNewTaskData(taskData);
+
 		taskData = new RepositoryTaskData(new MockAttributeFactory(), MockRepositoryConnector.REPOSITORY_KIND,
 				MockRepositoryConnector.REPOSITORY_URL, "2");
 
@@ -82,86 +75,75 @@ public class TaskDataManagerTest extends TestCase {
 		taskData.addAttribute("key", attrib2);
 
 		assertNotNull(taskData.getAttribute("key"));
-		
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "2"),
-				taskData);
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
-		offlineTaskDataManager.saveNow();
-		offlineTaskDataManager.clear();
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
-		offlineTaskDataManager.readOfflineData();
-		RepositoryTaskData loaded1 = offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1"));
-		assertNotNull(loaded1);
-
-		RepositoryTaskAttribute atr = loaded1.getAttribute("key");
-		assertNotNull(atr);
 
+		offlineTaskDataManager.setNewTaskData(taskData);
+
+		RepositoryTaskData loaded = offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1");
+		assertNotNull(loaded);
+		RepositoryTaskAttribute atr = loaded.getAttribute("key");
+		assertNotNull(atr);
 		assertEquals("value1", atr.getMetaDataValue("key1"));
 		assertEquals("value2", atr.getMetaDataValue("key2"));
 
-		RepositoryTaskData loaded2 = offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2"));
-		assertNotNull(loaded2);
-		RepositoryTaskAttribute atr2 = loaded2.getAttribute("key");
-		assertNotNull(atr2);
+		loaded = offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "2");
+		assertNotNull(loaded);
+		atr = loaded.getAttribute("key");
+		assertNotNull(atr);
+
+		assertEquals("value3", atr.getMetaDataValue("key3"));
+		assertEquals("value4", atr.getMetaDataValue("key4"));
+
+		offlineTaskDataManager.saveNow();
+		offlineTaskDataManager.remove(MockRepositoryConnector.REPOSITORY_URL, "1");
+		offlineTaskDataManager.remove(MockRepositoryConnector.REPOSITORY_URL, "2");
+
+		assertNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1"));
+		assertNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "2"));
 
-		assertEquals("value3", atr2.getMetaDataValue("key3"));
-		assertEquals("value4", atr2.getMetaDataValue("key4"));
 	}
 
 	public void testGetNextOfflineBugId() throws IOException, ClassNotFoundException {
 		assertEquals("1", offlineTaskDataManager.getNewRepositoryTaskId());
 		assertEquals("2", offlineTaskDataManager.getNewRepositoryTaskId());
 		offlineTaskDataManager.saveNow();
-		offlineTaskDataManager.clear();
-		offlineTaskDataManager.readOfflineData();
-		assertEquals("3", offlineTaskDataManager.getNewRepositoryTaskId());
+		offlineTaskDataManager.clear(); // currently resets new task id
+		assertEquals("1", offlineTaskDataManager.getNewRepositoryTaskId());
 	}
 
-	public void testGetTaskData() throws CoreException, IOException, ClassNotFoundException {
-		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(),
-				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		taskData.setNewComment("version 1");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
-		offlineTaskDataManager.setOldTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		taskData = new RepositoryTaskData(new MockAttributeFactory(), MockRepositoryConnector.REPOSITORY_KIND,
-				MockRepositoryConnector.REPOSITORY_URL, "1");
-		taskData.setNewComment("version 2");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
-		
-		offlineTaskDataManager.saveNow();
-		offlineTaskDataManager.clear();
-		offlineTaskDataManager.readOfflineData();
-		assertEquals("version 2", offlineTaskDataManager.getNewTaskData(
-				RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1")).getNewComment());
-		assertEquals("version 1", offlineTaskDataManager.getOldTaskData(
-				RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1")).getNewComment());
-	}
+//	public void testGetTaskData() throws CoreException, IOException, ClassNotFoundException {
+//		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(),
+//				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
+//		taskData.setNewComment("version 1");
+//		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
+//				taskData);
+//		offlineTaskDataManager.setOldTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
+//				taskData);
+//		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
+//				MockRepositoryConnector.REPOSITORY_URL, "1")));
+//		taskData = new RepositoryTaskData(new MockAttributeFactory(), MockRepositoryConnector.REPOSITORY_KIND,
+//				MockRepositoryConnector.REPOSITORY_URL, "1");
+//		taskData.setNewComment("version 2");
+//		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
+//				taskData);
+//		
+//		offlineTaskDataManager.saveNow();
+//		offlineTaskDataManager.clear();
+//		offlineTaskDataManager.readOfflineData();
+//		assertEquals("version 2", offlineTaskDataManager.getNewTaskData(
+//				RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1")).getNewComment());
+//		assertEquals("version 1", offlineTaskDataManager.getOldTaskData(MockRepositoryConnector.REPOSITORY_URL, "1").getNewComment());
+//	}
 
 	public void testUniqueCopy() throws Exception {
 		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(),
 				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
-		RepositoryTaskData taskData2 = offlineTaskDataManager.getEditableCopy(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1"));
+		offlineTaskDataManager.setNewTaskData(taskData);
+		RepositoryTaskData taskData2 = offlineTaskDataManager.getEditableCopy(MockRepositoryConnector.REPOSITORY_URL,
+				"1");
 		assertNotNull(taskData2);
 		taskData2.setNewComment("test");
 		taskData = null;
-		taskData = offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1"));
+		taskData = offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1");
 		assertFalse(taskData.getNewComment().equals("test"));
 //		taskData = null;
 //		taskData = offlineTaskDataManager.getOldTaskData(RepositoryTaskHandleUtil.getHandle(
@@ -172,75 +154,33 @@ public class TaskDataManagerTest extends TestCase {
 	public void testRemoveRepositoryTaskData() throws CoreException, IOException, ClassNotFoundException {
 		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(),
 				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
+		offlineTaskDataManager.setNewTaskData(taskData);
 		taskData = new RepositoryTaskData(new MockAttributeFactory(), MockRepositoryConnector.REPOSITORY_KIND,
 				MockRepositoryConnector.REPOSITORY_URL, "2");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "2"),
-				taskData);
-		offlineTaskDataManager.saveNow();
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
-		offlineTaskDataManager.remove(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "2"));
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
-		offlineTaskDataManager.saveNow();
-		offlineTaskDataManager.clear();
-		offlineTaskDataManager.readOfflineData();
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
-	}
-
-	public void testRemoveListOfRepositoryTaskData() throws CoreException, IOException, ClassNotFoundException {
-		RepositoryTaskData taskData1 = new RepositoryTaskData(new MockAttributeFactory(),
-				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData1);
-		RepositoryTaskData taskData2 = new RepositoryTaskData(new MockAttributeFactory(),
-				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "2");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "2"),
-				taskData2);
+		offlineTaskDataManager.setNewTaskData(taskData);
 		offlineTaskDataManager.saveNow();
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
-		ArrayList<String> list = new ArrayList<String>();
-		list.add(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"));
-		list.add(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "2"));
-		offlineTaskDataManager.remove(list);
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
+		assertNotNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1"));
+		assertNotNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "2"));
+		offlineTaskDataManager.remove(MockRepositoryConnector.REPOSITORY_URL, "2");
+		assertNotNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1"));
+		assertNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "2"));
 		offlineTaskDataManager.saveNow();
 		offlineTaskDataManager.clear();
-		offlineTaskDataManager.readOfflineData();
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
-		assertNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "2")));
+		assertNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1"));
+		assertNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "2"));
 	}
 
 	public void testEditing() {
 		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(),
 				MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL, "1");
-		offlineTaskDataManager.setNewTaskData(RepositoryTaskHandleUtil.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"),
-				taskData);
+		offlineTaskDataManager.setNewTaskData(taskData);
 
-		assertNotNull(offlineTaskDataManager.getNewTaskData(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1")));
+		assertNotNull(offlineTaskDataManager.getNewTaskData(MockRepositoryConnector.REPOSITORY_URL, "1"));
 //		assertNotNull(offlineTaskDataManager.getOldTaskData(RepositoryTaskHandleUtil.getHandle(
 //				MockRepositoryConnector.REPOSITORY_URL, "1")));
 
-		RepositoryTaskData editData = offlineTaskDataManager.getEditableCopy(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1"));
+		RepositoryTaskData editData = offlineTaskDataManager.getEditableCopy(MockRepositoryConnector.REPOSITORY_URL,
+				"1");
 		assertNotNull(editData);
 		editData.setAttributeFactory(new MockAttributeFactory());
 		editData.setAttributeValue(RepositoryTaskAttribute.COMMENT_NEW, "new comment");
@@ -250,12 +190,10 @@ public class TaskDataManagerTest extends TestCase {
 
 		Set<RepositoryTaskAttribute> attSave = new HashSet<RepositoryTaskAttribute>();
 		attSave.add(editData.getAttribute(RepositoryTaskAttribute.COMMENT_NEW));
-		offlineTaskDataManager.saveEdits(RepositoryTaskHandleUtil
-				.getHandle(MockRepositoryConnector.REPOSITORY_URL, "1"), attSave);
+		offlineTaskDataManager.saveEdits(MockRepositoryConnector.REPOSITORY_URL, "1", attSave);
 
 		editData = null;
-		editData = offlineTaskDataManager.getEditableCopy(RepositoryTaskHandleUtil.getHandle(
-				MockRepositoryConnector.REPOSITORY_URL, "1"));
+		editData = offlineTaskDataManager.getEditableCopy(MockRepositoryConnector.REPOSITORY_URL, "1");
 		assertNotNull(editData);
 		assertEquals("new comment", editData.getAttributeValue(RepositoryTaskAttribute.COMMENT_NEW));
 
diff --git a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskListManagerTest.java b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskListManagerTest.java
index 34f94dd74..70beaf7ab 100644
--- a/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskListManagerTest.java
+++ b/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/TaskListManagerTest.java
@@ -184,21 +184,25 @@ public class TaskListManagerTest extends TestCase {
 
 		RepositoryTaskData taskData = new RepositoryTaskData(new MockAttributeFactory(), task.getRepositoryKind(),
 				task.getRepositoryUrl(), task.getTaskId(), task.getTaskKind());
-		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(task.getHandleIdentifier(), taskData);
-		assertNotNull(TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getHandleIdentifier()));
+		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(taskData);
+		assertNotNull(TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task.getRepositoryUrl(),
+				task.getTaskId()));
 
 		RepositoryTaskData taskData2 = new RepositoryTaskData(new MockAttributeFactory(), task2.getRepositoryKind(),
 				task2.getRepositoryUrl(), task2.getTaskId(), task2.getTaskKind());
 		taskData2.setNewComment("TEST");
-		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(task2.getHandleIdentifier(), taskData2);
-		assertNotNull(TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task2.getHandleIdentifier()));
+		TasksUiPlugin.getDefault().getTaskDataManager().setNewTaskData(taskData2);
+		assertNotNull(TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task2.getRepositoryUrl(),
+				task2.getTaskId()));
+		assertEquals("TEST", TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(task2.getRepositoryUrl(),
+				task2.getTaskId()).getNewComment());
 
 		manager.refactorRepositoryUrl("http://a", "http://b");
 		assertNull(manager.getTaskList().getTask("http://a-123"));
 		assertNotNull(manager.getTaskList().getTask("http://b-123"));
-		assertNotNull(TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData("http://b-123"));
+		assertNotNull(TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData("http://b", "123"));
 		RepositoryTaskData otherData = TasksUiPlugin.getDefault().getTaskDataManager().getNewTaskData(
-				task2.getHandleIdentifier());
+				task2.getRepositoryUrl(), task2.getTaskId());
 		assertNotNull(otherData);
 		assertEquals("TEST", otherData.getNewComment());
 	}
@@ -559,7 +563,6 @@ public class TaskListManagerTest extends TestCase {
 
 		AbstractTask sub1 = manager.createNewLocalTask("sub 1");
 		manager.getTaskList().addTask(sub1, task1);
-		System.err.println(">>> " + task1.getChildren());
 
 		manager.getTaskList().moveToContainer(sub1, manager.getTaskList().getArchiveContainer());
 
@@ -609,7 +612,7 @@ public class TaskListManagerTest extends TestCase {
 		Set<AbstractTask> readList = manager.getTaskList().getDefaultCategory().getChildren();
 		for (AbstractTask task : readList) {
 			if (task.equals(task1)) {
-				System.err.println(">>> " + task.getChildren());
+				//System.err.println(">>> " + task.getChildren());
 				assertEquals(task1.getSummary(), task.getSummary());
 				assertEquals(1, task.getChildren().size());
 			}