Attachment 74255 Details for Bug 189518 – Queries importing/exporting and name conflict resolving

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] Queries importing/exporting and name conflict resolving

query-import-export-core-1_1-and-name-conflict-resolving.txt (text/plain), 20.54 KB, created by Jevgeni Holodkov

on 2007-07-20 09:55:26 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Jevgeni Holodkov

Created: 2007-07-20 09:55:26 EDT

Size: 20.54 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.mylyn.tasks.ui
>Index: src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java
>===================================================================
>RCS file: /cvsroot/tools/org.eclipse.mylyn/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java,v
>retrieving revision 1.36
>diff -u -r1.36 TaskListWriter.java
>--- src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java	10 Jul 2007 20:00:47 -0000	1.36
>+++ src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java	20 Jul 2007 13:51:29 -0000
>@@ -57,6 +57,7 @@
>  * @author Mik Kersten
>  * @author Ken Sueda
>  * @author Rob Elves
>+ * @author Jevgeni Holodkov
>  * 
>  * TODO: move to core?
>  */
>@@ -338,8 +339,11 @@
> 		}
> 	}
> 
>-	private void readQuery(TaskList taskList, Node child) {
>-		boolean wasRead = false;
>+	/** 
>+	 * Reads the Query from the specified Node. If taskList is not null, then also adds this query to the TaskList
>+	 */
>+	private AbstractRepositoryQuery readQuery(TaskList taskList, Node child) {
>+		AbstractRepositoryQuery query = null;
> 		for (AbstractTaskListFactory externalizer : externalizers) {
> 			Set<String> queryTagNames = externalizer.getQueryElementNames();
> 			if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {
>@@ -355,32 +359,41 @@
> 					label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);
> 				}
> 
>-				AbstractRepositoryQuery query = externalizer.createQuery(repositoryUrl,
>-						queryString, label, childElement);
>+				query = externalizer.createQuery(repositoryUrl,	queryString, label, childElement);
> 				if (query != null) {
>-					wasRead = true;
> 					if (childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH) != null
> 							&& !childElement.getAttribute(
> 									DelegatingTaskExternalizer.KEY_LAST_REFRESH).equals("")) {
> 						query.setLastSynchronizedStamp(childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH));
> 					}
>-					taskList.internalAddQuery(query);
> 				}
>-				NodeList queryChildren = child.getChildNodes();
>-				for (int ii = 0; ii < queryChildren.getLength(); ii++) {
>-					Node queryNode = queryChildren.item(ii);
>-					try {
>-						delagatingExternalizer.readQueryHit((Element) queryNode, taskList, query);
>-					} catch (TaskExternalizationException e) {
>-						hasCaughtException = true;
>+				
>+				// add created Query to the TaskList and read QueryHits (Tasks related to the Query)
>+				if (taskList != null) {
>+					if (query != null) {
>+						taskList.internalAddQuery(query);
>+					}
>+
>+					NodeList queryChildren = child.getChildNodes();
>+					for (int ii = 0; ii < queryChildren.getLength(); ii++) {
>+						Node queryNode = queryChildren.item(ii);
>+						try {
>+							delagatingExternalizer.readQueryHit((Element) queryNode, taskList, query);
>+						} catch (TaskExternalizationException e) {
>+							hasCaughtException = true;
>+						}
> 					}
> 				}
>+				
>+
> 				break;
> 			}
> 		}
>-		if (!wasRead) {
>+		if (query == null) {
> 			orphanedQueryNodes.add(child);
> 		}
>+		
>+		return query;
> 	}
> 
> 	/**
>@@ -480,7 +493,18 @@
> 		return externalizers;
> 	}
> 
>-	public void writeQuery(AbstractRepositoryQuery query, File outFile) {
>+	public void writeQueries(List<AbstractRepositoryQuery> queries, File outFile) {
>+		Document doc = createQueryDocument(queries);
>+		if (doc != null) {
>+			writeDOMtoFile(doc, outFile);
>+		}
>+		return;
>+	}
>+
>+	/**
>+	 * @return null if it was not possible to create the Query document.
>+	 */
>+	public Document createQueryDocument(List<AbstractRepositoryQuery> queries) {
> 		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
> 		DocumentBuilder db;
> 		Document doc = null;
>@@ -490,59 +514,78 @@
> 			doc = db.newDocument();
> 		} catch (ParserConfigurationException e) {
> 			StatusHandler.log(e, "could not create document");
>-			return;
>+			return null;
> 		}
> 
> 		Element root = doc.createElement(ELEMENT_TASK_LIST);
> 		root.setAttribute(ATTRIBUTE_VERSION, VALUE_VERSION);
> 
>+		
>+		
>+		
>+		
>+		
>+		
>+		for (AbstractRepositoryQuery query : queries) {
> 			try {
> 				delagatingExternalizer.createQueryElement(query, doc, root);
> 			} catch (Throwable t) {
> 				StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);
>+				return null;
> 			}
>+		}
> 
> 		doc.appendChild(root);
>-		writeDOMtoFile(doc, outFile);
>-		return;
>+		return doc;
> 	}
> 
>-	public void readQueries(TaskList taskList, File inFile) {
>+	public List<AbstractRepositoryQuery> readQueries(File inFile) {
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
> 		try {
> 			if (!inFile.exists())
>-				return;
>+				return queries;
> 			Document doc = openAsDOM(inFile);
> 			if (doc == null) {
> 				handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));
>-				return;
>+				return queries;
> 			}
>-			Element root = doc.getDocumentElement();
>-			readVersion = root.getAttribute(ATTRIBUTE_VERSION);
>-
>-			if (!readVersion.equals(VALUE_VERSION_1_0_0)) {
>-				NodeList list = root.getChildNodes();
>+			queries = readQueryDocument(doc);
>+		} catch (Exception e) {
>+			handleException(inFile, null, e);
>+		}
>+		
>+		return queries;
>+	}
> 
>-				// read queries
>-				for (int i = 0; i < list.getLength(); i++) {
>-					Node child = list.item(i);
>-					try {
>-						if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
>-							readQuery(taskList, child);
>+	/**
>+	 * @param Query document to read.
>+	 */
>+	public List<AbstractRepositoryQuery> readQueryDocument(Document doc) {
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
>+		Element root = doc.getDocumentElement();
>+		readVersion = root.getAttribute(ATTRIBUTE_VERSION);
>+
>+		if (!readVersion.equals(VALUE_VERSION_1_0_0)) {
>+			NodeList list = root.getChildNodes();
>+
>+			// read queries
>+			for (int i = 0; i < list.getLength(); i++) {
>+				Node child = list.item(i);
>+				try {
>+					if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
>+						AbstractRepositoryQuery query = readQuery(null, child);
>+						if (query != null) {
>+							queries.add(query);
> 						}
>-					} catch (Exception e) {
>-						handleException(inFile, child, e);
> 					}
>+				} catch (Exception e) {
>+					StatusHandler.log(e, "Tasks may have been lost from " + child.getNodeName());
> 				}
>-			} else {
>-				StatusHandler.log("version: " + readVersion + " not supported", this);
> 			}
>-		} catch (Exception e) {
>-			handleException(inFile, null, e);
>+		} else {
>+			StatusHandler.log("version: " + readVersion + " not supported", this);
> 		}
> 		
>-		if (!hasCaughtException) {
>-			// save new task list only if there were no exception!
>-			writeTaskList(taskList, inFile);
>-		}
>+		return queries;
> 	}
> }
>Index: src/org/eclipse/mylyn/tasks/ui/TaskListManager.java
>===================================================================
>RCS file: /cvsroot/tools/org.eclipse.mylyn/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/tasks/ui/TaskListManager.java,v
>retrieving revision 1.101
>diff -u -r1.101 TaskListManager.java
>--- src/org/eclipse/mylyn/tasks/ui/TaskListManager.java	10 Jul 2007 00:30:40 -0000	1.101
>+++ src/org/eclipse/mylyn/tasks/ui/TaskListManager.java	20 Jul 2007 13:51:29 -0000
>@@ -14,6 +14,7 @@
> import java.util.Calendar;
> import java.util.Date;
> import java.util.GregorianCalendar;
>+import java.util.HashMap;
> import java.util.HashSet;
> import java.util.List;
> import java.util.Map;
>@@ -21,6 +22,8 @@
> import java.util.Timer;
> import java.util.TimerTask;
> import java.util.concurrent.ConcurrentHashMap;
>+import java.util.regex.Matcher;
>+import java.util.regex.Pattern;
> 
> import org.eclipse.core.runtime.Platform;
> import org.eclipse.jface.dialogs.MessageDialog;
>@@ -48,6 +51,8 @@
> import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
> import org.eclipse.mylyn.monitor.core.InteractionEvent;
> import org.eclipse.mylyn.monitor.core.StatusHandler;
>+import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
>+import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
> import org.eclipse.mylyn.tasks.core.AbstractTask;
> import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
> import org.eclipse.mylyn.tasks.core.ITaskActivityListener;
>@@ -67,6 +72,7 @@
>  * 
>  * @author Mik Kersten
>  * @author Rob Elves (task activity)
>+ * @author Jevgeni Holodkov (insertQueries)
>  * @since 2.0
>  */
> public class TaskListManager implements IPropertyChangeListener {
>@@ -1190,4 +1196,66 @@
> 		return newTask;
> 	}
> 
>+	
>+	/**
>+	 * Imports Queries to the TaskList and synchronize them with the repository. If the imported query have the
>+	 * name that overlaps with the existing one, the the suffix [x] is added, where x is a number starting from 1.
>+	 * @param queries to insert
>+	 * @return the list queries, which were not inserted since because the related repository was not found.
>+	 */
>+	public List<AbstractRepositoryQuery> insertQueries(List<AbstractRepositoryQuery> queries) {
>+		List<AbstractRepositoryQuery> badQueries = new ArrayList<AbstractRepositoryQuery>();
>+		
>+		String patternStr = "\\[(\\d+)\\]$"; // all string that end with [x], where x is a number
>+	    Pattern pattern = Pattern.compile(patternStr);
>+		
>+		for (AbstractRepositoryQuery query : queries) {
>+
>+			TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(
>+					query.getRepositoryKind(), query.getRepositoryUrl());
>+			if (repository == null) {
>+				badQueries.add(query);
>+				continue;
>+			}
>+
>+			// resolve name conflict
>+			{
>+				Set<AbstractRepositoryQuery> existingQueries = getTaskList().getQueries();
>+				Map<String, AbstractRepositoryQuery> queryMap = new HashMap<String, AbstractRepositoryQuery>();
>+				for (AbstractRepositoryQuery existingQuery : existingQueries) {
>+					queryMap.put(existingQuery.getHandleIdentifier(), existingQuery);
>+				}
>+
>+				// suggest a new handle if needed
>+				String handle = query.getHandleIdentifier();
>+				
>+				while (queryMap.get(handle) != null) {
>+					Matcher matcher = pattern.matcher(handle);
>+					boolean matchFound = matcher.find();
>+					if (matchFound) {
>+						// increment index
>+						int index = Integer.parseInt(matcher.group(1));
>+						index++;
>+						handle = matcher.replaceAll("[" + index + "]");
>+					} else {
>+						handle += "[1]";
>+					}
>+				}
>+				query.setHandleIdentifier(handle);
>+			}
>+
>+			// add query
>+			TasksUiPlugin.getTaskListManager().getTaskList().addQuery(query);
>+
>+			AbstractRepositoryConnector connector = TasksUiPlugin.getRepositoryManager()
>+					.getRepositoryConnector(repository.getConnectorKind());
>+			if (connector != null) {
>+				TasksUiPlugin.getSynchronizationManager().synchronize(connector, query, null, true);
>+			}
>+
>+		}
>+		
>+		return badQueries;
>+	}
>+
> }
>#P org.eclipse.mylyn.tasks.tests
>Index: src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java
>===================================================================
>RCS file: /cvsroot/tools/org.eclipse.mylyn/org.eclipse.mylyn.tasks.tests/src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java,v
>retrieving revision 1.1
>diff -u -r1.1 QueryExportImportTest.java
>--- src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java	10 Jul 2007 20:00:48 -0000	1.1
>+++ src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java	20 Jul 2007 13:51:33 -0000
>@@ -13,14 +13,17 @@
> 
> import java.io.File;
> import java.util.ArrayList;
>+import java.util.HashMap;
> import java.util.List;
>+import java.util.Map;
> import java.util.Set;
> 
> import junit.framework.TestCase;
> 
> import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
> import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
>-import org.eclipse.mylyn.tasks.core.TaskList;
>+import org.eclipse.mylyn.tasks.core.TaskRepository;
>+import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
> import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
> import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;
> import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
>@@ -62,23 +65,177 @@
> 		externalizers.add(new MockTaskListFactory());
> 		TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);
> 
>-		MockRepositoryQuery query = new MockRepositoryQuery("Test Query");
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
>+		
>+		MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
>+		MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query 2");
>+		queries.add(query1);
>+		queries.add(query2);
> 
> 		File outFile = new File(dest, "test-query.xml.zip");
> 		
>-		TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQuery(query, outFile);
>+		TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQueries(queries, outFile);
> 		assertTrue(outFile.exists());
> 		
>-		TaskList taskList = TasksUiPlugin.getTaskListManager().resetTaskList();
>-
> 		File inFile = new File(dest, "test-query.xml.zip");
>-		TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(taskList, inFile);		
>-		Set<AbstractRepositoryQuery> queries = taskList.getQueries();
>-		assertEquals("1 Query is imported", 1, queries.size());
>+		List<AbstractRepositoryQuery> resultQueries = TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(
>+				inFile);		
>+		assertEquals("2 Queries is imported", 2, resultQueries.size());
>+	}
>+	
>+	public void testImportedQueriesNameConflictResolving1() {
>+		// prepare for test
>+		TasksUiPlugin.getTaskListManager().resetTaskList();
>+		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
>+		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
>+		
>+		// create test data
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
>+		
>+		MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
>+		query1.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query2 = new MockRepositoryQuery("Test Query");
>+		query2.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query3 = new MockRepositoryQuery("Test Query");
>+		query3.setRepositoryUrl(repository.getUrl());
>+		
>+		queries.add(query1);
>+		queries.add(query2);
>+		queries.add(query3);
>+		
>+		// run tested functionality
>+		TasksUiPlugin.getTaskListManager().insertQueries(queries);
>+		
>+		// extract results
>+		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
>+		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
>+		for (AbstractRepositoryQuery query : queriesSet) {
>+			queriesMap.put(query.getHandleIdentifier(), query);
>+		}
>+		
>+		// check that the actual result is correct
>+		assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
>+		assertTrue("'Test Query[1]' query inserted", queriesMap.containsKey("Test Query[1]"));
>+		assertTrue("'Test Query[2]' query inserted", queriesMap.containsKey("Test Query[2]"));
> 	}
> 	
>+
>+	public void testImportedQueriesNameConflictResolving2() {
>+		// prepare for test
>+		TasksUiPlugin.getTaskListManager().resetTaskList();
>+		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
>+		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
>+		
>+		// create test data
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
>+		
>+		MockRepositoryQuery query1 = new MockRepositoryQuery("Test2");
>+		query1.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query2 = new MockRepositoryQuery("Test2[1]");
>+		query2.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query3 = new MockRepositoryQuery("Test2");
>+		query3.setRepositoryUrl(repository.getUrl());
>+		
>+		queries.add(query1);
>+		queries.add(query2);
>+		queries.add(query3);
>+		
>+		// run tested functionality
>+		TasksUiPlugin.getTaskListManager().insertQueries(queries);
>+		
>+		// extract results
>+		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
>+		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
>+		for (AbstractRepositoryQuery query : queriesSet) {
>+			queriesMap.put(query.getHandleIdentifier(), query);
>+		}
>+		
>+		// check that the actual result is correct
>+		assertTrue("'Test2' query inserted", queriesMap.containsKey("Test2"));
>+		assertTrue("'Test2[1]' query inserted", queriesMap.containsKey("Test2[1]"));
>+		assertTrue("'Test2[2]' query inserted", queriesMap.containsKey("Test2[2]"));
>+		
>+	}
> 	
> 
>+	public void testImportedBadQueriesNameConflictResolving() {
>+		// prepare for test
>+		TasksUiPlugin.getTaskListManager().resetTaskList();
>+		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
>+		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
>+		
>+		// create test data
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
>+		
>+		MockRepositoryQuery query1 = new MockRepositoryQuery("Test[-10]");
>+		query1.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query2 = new MockRepositoryQuery("Test[ABC]");
>+		query2.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query3 = new MockRepositoryQuery("Test[1]");
>+		query3.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query4 = new MockRepositoryQuery("Test");
>+		query4.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query5 = new MockRepositoryQuery("Test");
>+		query5.setRepositoryUrl(repository.getUrl());
>+		
>+		queries.add(query1);
>+		queries.add(query2);
>+		queries.add(query3);
>+		queries.add(query4);
>+		queries.add(query5);
>+		
>+		// run tested functionality
>+		TasksUiPlugin.getTaskListManager().insertQueries(queries);
>+		
>+		// extract results
>+		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
>+		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
>+		for (AbstractRepositoryQuery query : queriesSet) {
>+			queriesMap.put(query.getHandleIdentifier(), query);
>+		}
>+		
>+		// check that the actual result is correct
>+		assertTrue("'Test[-10]' query inserted", queriesMap.containsKey("Test[-10]"));
>+		assertTrue("'Test[ABC]' query inserted", queriesMap.containsKey("Test[ABC]"));
>+		assertTrue("'Test[1]' query inserted", queriesMap.containsKey("Test[1]"));
>+		assertTrue("'Test' query inserted", queriesMap.containsKey("Test"));
>+		assertTrue("Another 'Test' query inserted", queriesMap.containsKey("Test[2]"));
>+	}
>+	
>+	public void testImportedBadQueries() {
>+		// prepare for test
>+		TasksUiPlugin.getTaskListManager().resetTaskList();
>+		TaskRepository repository = new TaskRepository(MockRepositoryConnector.REPOSITORY_KIND, MockRepositoryConnector.REPOSITORY_URL);
>+		TasksUiPlugin.getRepositoryManager().addRepository(repository, TasksUiPlugin.getDefault().getRepositoriesFilePath());
>+		
>+		// create test data
>+		List<AbstractRepositoryQuery> queries = new ArrayList<AbstractRepositoryQuery>();
>+		
>+		MockRepositoryQuery query1 = new MockRepositoryQuery("Test Query");
>+		query1.setRepositoryUrl(repository.getUrl());
>+		MockRepositoryQuery query2 = new MockRepositoryQuery("Bad Query");
>+		query2.setRepositoryUrl("bad url");
>+		
>+		queries.add(query1);
>+		queries.add(query2);
>+		
>+		// run tested functionality
>+		List<AbstractRepositoryQuery> badQueries = TasksUiPlugin.getTaskListManager().insertQueries(queries);
>+		
>+		// extract results
>+		Set<AbstractRepositoryQuery> queriesSet = TasksUiPlugin.getTaskListManager().getTaskList().getQueries();
>+		Map<String, AbstractRepositoryQuery> queriesMap = new HashMap<String, AbstractRepositoryQuery>();
>+		for (AbstractRepositoryQuery query : queriesSet) {
>+			queriesMap.put(query.getHandleIdentifier(), query);
>+		}
>+		
>+		// check that the actual result is correct
>+		assertEquals("There is a bad query", 1, badQueries.size());
>+		assertEquals(query2, badQueries.get(0));
>+		assertTrue("'Test Query' query inserted", queriesMap.containsKey("Test Query"));
>+	}
>+	
>+	
> 	private void removeFiles(File root) {
> 		if (root.isDirectory()) {
> 			for (File file : root.listFiles()) {

Actions: View | Diff

Attachments on bug 189518: 73436 | 73437 | 73863 | 73864 | 74255 | 74256 | 74262 | 74263 | 74311 | 75245 | 75246