Attachment #73436 for bug #189518

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

Lines 50-55 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java (+1 lines)
50	suite.addTestSuite(CommentQuoterTest.class);	50	suite.addTestSuite(CommentQuoterTest.class);
51	suite.addTestSuite(OfflineStorageTest.class);	51	suite.addTestSuite(OfflineStorageTest.class);
52	suite.addTestSuite(OfflineCachingStorageTest.class);	52	suite.addTestSuite(OfflineCachingStorageTest.class);
		53	suite.addTestSuite(QueryExportImportTest.class);
53	// $JUnit-END$	54	// $JUnit-END$
54		55
55	// suite.addTestSuite(BackgroundSaveTest.class);	56	// suite.addTestSuite(BackgroundSaveTest.class);

Lines 8-13 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/connector/MockTaskListFactory.java (+29 lines)
8		8
9	package org.eclipse.mylyn.tasks.tests.connector;	9	package org.eclipse.mylyn.tasks.tests.connector;
10		10
		11	import java.util.HashSet;
		12	import java.util.Set;
		13
		14	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
11	import org.eclipse.mylyn.tasks.core.AbstractTask;	15	import org.eclipse.mylyn.tasks.core.AbstractTask;
12	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;	16	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
13	import org.w3c.dom.Element;	17	import org.w3c.dom.Element;
Lines 16-26 Link Here
16	* @author Mik Kersten	20	* @author Mik Kersten
17	*/	21	*/
18	public class MockTaskListFactory extends AbstractTaskListFactory {	22	public class MockTaskListFactory extends AbstractTaskListFactory {
		23
		24	private static final String QUERY_ELEMENT_NAME = "MockQuery";
19		25
20	@Override	26	@Override
21	public boolean canCreate(AbstractTask task) {	27	public boolean canCreate(AbstractTask task) {
22	return task instanceof MockRepositoryTask;	28	return task instanceof MockRepositoryTask;
23	}	29	}
		30
		31	@Override
		32	public boolean canCreate(AbstractRepositoryQuery query) {
		33	return query instanceof MockRepositoryQuery;
		34	}
24		35
25	@Override	36	@Override
26	public AbstractTask createTask(String repositoryUrl, String taskId, String summary, Element element) {	37	public AbstractTask createTask(String repositoryUrl, String taskId, String summary, Element element) {
Lines 33-38 Link Here
33	return "Mock" + AbstractTaskListFactory.KEY_TASK;	44	return "Mock" + AbstractTaskListFactory.KEY_TASK;
34	}	45	}
35		46
		47	@Override
		48	public String getQueryElementName(AbstractRepositoryQuery query) {
		49	return QUERY_ELEMENT_NAME;
		50	}
		51
		52	@Override
		53	public AbstractRepositoryQuery createQuery(String repositoryUrl, String queryString, String label, Element element) {
		54	MockRepositoryQuery query = new MockRepositoryQuery(label, queryString);
		55	return query;
		56	}
		57
		58	@Override
		59	public Set<String> getQueryElementNames() {
		60	Set<String> names = new HashSet<String>();
		61	names.add(QUERY_ELEMENT_NAME);
		62	return names;
		63	}
		64
36	// private static final String KEY_MOCK = "Mock";	65	// private static final String KEY_MOCK = "Mock";
37	//	66	//
38	// @Override	67	// @Override




/*******************************************************************************
 * Copyright (c) 2004 - 2006 University Of British Columbia 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:
 *     University Of British Columbia - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.tasks.tests;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.eclipse.mylyn.context.core.ContextCorePlugin;
import org.eclipse.mylyn.monitor.core.StatusHandler;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
import org.eclipse.mylyn.tasks.core.QueryHitCollector;
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.TaskFactory;
import org.eclipse.mylyn.tasks.ui.TaskListManager;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;

import junit.framework.TestCase;

public class QueryExportImportTest extends 	TestCase {

	private File dest;
	
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		
		removeFiles(new File(TasksUiPlugin.getDefault().getDataDirectory()));
		
		// Create test export destination directory
		dest = new File(TasksUiPlugin.getDefault().getDataDirectory() + File.separator + "TestDir");
		if (dest.exists()) {
			removeFiles(dest);
		} else {
			dest.mkdir();
		}
		assertTrue(dest.exists());
	}

	@Override
	protected void tearDown() throws Exception {
		super.tearDown();
		
		removeFiles(dest);
		dest.delete();
		assertFalse(dest.exists());
	}
	
	public void testExportImportQuery() {
		List<AbstractTaskListFactory> externalizers = new ArrayList<AbstractTaskListFactory>();
		externalizers.add(new MockTaskListFactory());
		TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);

		MockRepositoryQuery query = new MockRepositoryQuery("Test Query");

		File outFile = new File(dest, "test-query.xml.zip");
		
		TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQuery(query, 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());
	}
	
	

	private void removeFiles(File root) {
		if (root.isDirectory()) {
			for (File file : root.listFiles()) {
				if (file.isDirectory()) {
					removeFiles(file);
				}
				file.delete();
			}
		}
	}

}




				for (int i = 0; i < list.getLength(); i++) {
					Node child = list.item(i);
					try {
						boolean wasRead = false;
						if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
							readQuery(taskList, child);
								Set<String> queryTagNames = externalizer.getQueryElementNames();
								if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {
									Element childElement = (Element) child;
									// TODO: move this stuff into externalizer
									String repositoryUrl = childElement.getAttribute(DelegatingTaskExternalizer.KEY_REPOSITORY_URL);
									String queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY_STRING);
									if (queryString.length() == 0) { // fallback for legacy
										queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY);
									}
									String label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_NAME);
									if (label.length() == 0) { // fallback for legacy
										label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);
									}

									AbstractRepositoryQuery 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;
										}
									}
									break;
								}
							}
							if (!wasRead) {
								orphanedQueryNodes.add(child);
							}
						}
					} catch (Exception e) {
						handleException(inFile, child, e);

		}
	}

	private void readQuery(TaskList taskList, Node child) {
		boolean wasRead = false;
		for (AbstractTaskListFactory externalizer : externalizers) {
			Set<String> queryTagNames = externalizer.getQueryElementNames();
			if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {
				Element childElement = (Element) child;
				// TODO: move this stuff into externalizer
				String repositoryUrl = childElement.getAttribute(DelegatingTaskExternalizer.KEY_REPOSITORY_URL);
				String queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY_STRING);
				if (queryString.length() == 0) { // fallback for legacy
					queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY);
				}
				String label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_NAME);
				if (label.length() == 0) { // fallback for legacy
					label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);
				}

				AbstractRepositoryQuery 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;
					}
				}
				break;
			}
		}
		if (!wasRead) {
			orphanedQueryNodes.add(child);
		}
	}

	/**
	 * Opens the specified XML file and parses it into a DOM Document.
	 * 

			// Parse the content of the given file as an XML document
			// and return a new DOM Document object. Also throws IOException
			InputStream inputStream = null;
			if (inputFile.getName().endsWith(ITasksUiConstants.FILE_EXTENSION)) {
				// is zipped context
				inputStream = new ZipInputStream(new FileInputStream(inputFile));
				((ZipInputStream) inputStream).getNextEntry();

	public List<AbstractTaskListFactory> getExternalizers() {
		return externalizers;
	}

	public void writeQuery(AbstractRepositoryQuery query, File outFile) {
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db;
		Document doc = null;

		try {
			db = dbf.newDocumentBuilder();
			doc = db.newDocument();
		} catch (ParserConfigurationException e) {
			StatusHandler.log(e, "could not create document");
			return;
		}

		Element root = doc.createElement(ELEMENT_TASK_LIST);
		root.setAttribute(ATTRIBUTE_VERSION, VALUE_VERSION);

			try {
				delagatingExternalizer.createQueryElement(query, doc, root);
			} catch (Throwable t) {
				StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);
			}

		doc.appendChild(root);
		writeDOMtoFile(doc, outFile);
		return;
	}

	public void readQueries(TaskList taskList, File inFile) {
		try {
			if (!inFile.exists())
				return;
			Document doc = openAsDOM(inFile);
			if (doc == null) {
				handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));
				return;
			}
			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)) {
							readQuery(taskList, child);
						}
					} catch (Exception e) {
						handleException(inFile, child, e);
					}
				}
			} else {
				StatusHandler.log("version: " + readVersion + " not supported", this);
			}
		} catch (Exception e) {
			handleException(inFile, null, e);
		}
		
		if (!hasCaughtException) {
			// save new task list only if there were no exception!
			writeTaskList(taskList, inFile);
		}
	}
}

Return to bug 189518

Lines 312-360 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/util/TaskListWriter.java (-43 / +113 lines)
312	for (int i = 0; i < list.getLength(); i++) {	312	for (int i = 0; i < list.getLength(); i++) {
313	Node child = list.item(i);	313	Node child = list.item(i);
314	try {	314	try {
315	boolean wasRead = false;
316	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {	315	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
317	for (AbstractTaskListFactory externalizer : externalizers) {	316	readQuery(taskList, child);
318	Set<String> queryTagNames = externalizer.getQueryElementNames();
319	if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {
320	Element childElement = (Element) child;
321	// TODO: move this stuff into externalizer
322	String repositoryUrl = childElement.getAttribute(DelegatingTaskExternalizer.KEY_REPOSITORY_URL);
323	String queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY_STRING);
324	if (queryString.length() == 0) { // fallback for legacy
325	queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY);
326	}
327	String label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_NAME);
328	if (label.length() == 0) { // fallback for legacy
329	label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);
330	}
331
332	AbstractRepositoryQuery query = externalizer.createQuery(repositoryUrl,
333	queryString, label, childElement);
334	if (query != null) {
335	wasRead = true;
336	if (childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH) != null
337	&& !childElement.getAttribute(
338	DelegatingTaskExternalizer.KEY_LAST_REFRESH).equals("")) {
339	query.setLastSynchronizedStamp(childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH));
340	}
341	taskList.internalAddQuery(query);
342	}
343	NodeList queryChildren = child.getChildNodes();
344	for (int ii = 0; ii < queryChildren.getLength(); ii++) {
345	Node queryNode = queryChildren.item(ii);
346	try {
347	delagatingExternalizer.readQueryHit((Element) queryNode, taskList, query);
348	} catch (TaskExternalizationException e) {
349	hasCaughtException = true;
350	}
351	}
352	break;
353	}
354	}
355	if (!wasRead) {
356	orphanedQueryNodes.add(child);
357	}
358	}	317	}
359	} catch (Exception e) {	318	} catch (Exception e) {
360	handleException(inFile, child, e);	319	handleException(inFile, child, e);
Lines 379-384 Link Here
379	}	338	}
380	}	339	}
381		340
		341	private void readQuery(TaskList taskList, Node child) {
		342	boolean wasRead = false;
		343	for (AbstractTaskListFactory externalizer : externalizers) {
		344	Set<String> queryTagNames = externalizer.getQueryElementNames();
		345	if (queryTagNames != null && queryTagNames.contains(child.getNodeName())) {
		346	Element childElement = (Element) child;
		347	// TODO: move this stuff into externalizer
		348	String repositoryUrl = childElement.getAttribute(DelegatingTaskExternalizer.KEY_REPOSITORY_URL);
		349	String queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY_STRING);
		350	if (queryString.length() == 0) { // fallback for legacy
		351	queryString = childElement.getAttribute(AbstractTaskListFactory.KEY_QUERY);
		352	}
		353	String label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_NAME);
		354	if (label.length() == 0) { // fallback for legacy
		355	label = childElement.getAttribute(DelegatingTaskExternalizer.KEY_LABEL);
		356	}
		357
		358	AbstractRepositoryQuery query = externalizer.createQuery(repositoryUrl,
		359	queryString, label, childElement);
		360	if (query != null) {
		361	wasRead = true;
		362	if (childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH) != null
		363	&& !childElement.getAttribute(
		364	DelegatingTaskExternalizer.KEY_LAST_REFRESH).equals("")) {
		365	query.setLastSynchronizedStamp(childElement.getAttribute(DelegatingTaskExternalizer.KEY_LAST_REFRESH));
		366	}
		367	taskList.internalAddQuery(query);
		368	}
		369	NodeList queryChildren = child.getChildNodes();
		370	for (int ii = 0; ii < queryChildren.getLength(); ii++) {
		371	Node queryNode = queryChildren.item(ii);
		372	try {
		373	delagatingExternalizer.readQueryHit((Element) queryNode, taskList, query);
		374	} catch (TaskExternalizationException e) {
		375	hasCaughtException = true;
		376	}
		377	}
		378	break;
		379	}
		380	}
		381	if (!wasRead) {
		382	orphanedQueryNodes.add(child);
		383	}
		384	}
		385
382	/**	386	/**
383	* Opens the specified XML file and parses it into a DOM Document.	387	* Opens the specified XML file and parses it into a DOM Document.
384	*	388	*
Lines 407-413 Link Here
407	// Parse the content of the given file as an XML document	411	// Parse the content of the given file as an XML document
408	// and return a new DOM Document object. Also throws IOException	412	// and return a new DOM Document object. Also throws IOException
409	InputStream inputStream = null;	413	InputStream inputStream = null;
410	if (inputFile.getName().endsWith(ITasksUiConstants.DEFAULT_TASK_LIST_FILE)) {	414	if (inputFile.getName().endsWith(ITasksUiConstants.FILE_EXTENSION)) {
411	// is zipped context	415	// is zipped context
412	inputStream = new ZipInputStream(new FileInputStream(inputFile));	416	inputStream = new ZipInputStream(new FileInputStream(inputFile));
413	((ZipInputStream) inputStream).getNextEntry();	417	((ZipInputStream) inputStream).getNextEntry();
Lines 475-478 Link Here
475	public List<AbstractTaskListFactory> getExternalizers() {	479	public List<AbstractTaskListFactory> getExternalizers() {
476	return externalizers;	480	return externalizers;
477	}	481	}
		482
		483	public void writeQuery(AbstractRepositoryQuery query, File outFile) {
		484	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		485	DocumentBuilder db;
		486	Document doc = null;
		487
		488	try {
		489	db = dbf.newDocumentBuilder();
		490	doc = db.newDocument();
		491	} catch (ParserConfigurationException e) {
		492	StatusHandler.log(e, "could not create document");
		493	return;
		494	}
		495
		496	Element root = doc.createElement(ELEMENT_TASK_LIST);
		497	root.setAttribute(ATTRIBUTE_VERSION, VALUE_VERSION);
		498
		499	try {
		500	delagatingExternalizer.createQueryElement(query, doc, root);
		501	} catch (Throwable t) {
		502	StatusHandler.fail(t, "Did not externalize: " + query.getSummary(), true);
		503	}
		504
		505	doc.appendChild(root);
		506	writeDOMtoFile(doc, outFile);
		507	return;
		508	}
		509
		510	public void readQueries(TaskList taskList, File inFile) {
		511	try {
		512	if (!inFile.exists())
		513	return;
		514	Document doc = openAsDOM(inFile);
		515	if (doc == null) {
		516	handleException(inFile, null, new TaskExternalizationException("TaskList was not well formed XML"));
		517	return;
		518	}
		519	Element root = doc.getDocumentElement();
		520	readVersion = root.getAttribute(ATTRIBUTE_VERSION);
		521
		522	if (!readVersion.equals(VALUE_VERSION_1_0_0)) {
		523	NodeList list = root.getChildNodes();
		524
		525	// read queries
		526	for (int i = 0; i < list.getLength(); i++) {
		527	Node child = list.item(i);
		528	try {
		529	if (child.getNodeName().endsWith(AbstractTaskListFactory.KEY_QUERY)) {
		530	readQuery(taskList, child);
		531	}
		532	} catch (Exception e) {
		533	handleException(inFile, child, e);
		534	}
		535	}
		536	} else {
		537	StatusHandler.log("version: " + readVersion + " not supported", this);
		538	}
		539	} catch (Exception e) {
		540	handleException(inFile, null, e);
		541	}
		542
		543	if (!hasCaughtException) {
		544	// save new task list only if there were no exception!
		545	writeTaskList(taskList, inFile);
546	}
547	}
478	}	548	}

Added Link Here

(-)src/org/eclipse/mylyn/tasks/tests/QueryExportImportTest.java (+99 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004 - 2006 University Of British Columbia and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* University Of British Columbia - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.tasks.tests;
13
14	import java.io.File;
15	import java.io.UnsupportedEncodingException;
16	import java.net.URLEncoder;
17	import java.util.ArrayList;
18	import java.util.List;
19	import java.util.Set;
20
21	import org.eclipse.mylyn.context.core.ContextCorePlugin;
22	import org.eclipse.mylyn.monitor.core.StatusHandler;
23	import org.eclipse.mylyn.tasks.core.AbstractRepositoryQuery;
24	import org.eclipse.mylyn.tasks.core.AbstractTaskListFactory;
25	import org.eclipse.mylyn.tasks.core.QueryHitCollector;
26	import org.eclipse.mylyn.tasks.core.TaskList;
27	import org.eclipse.mylyn.tasks.core.TaskRepository;
28	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryConnector;
29	import org.eclipse.mylyn.tasks.tests.connector.MockRepositoryQuery;
30	import org.eclipse.mylyn.tasks.tests.connector.MockTaskListFactory;
31	import org.eclipse.mylyn.tasks.ui.TaskFactory;
32	import org.eclipse.mylyn.tasks.ui.TaskListManager;
33	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
34
35	import junit.framework.TestCase;
36
37	public class QueryExportImportTest extends TestCase {
38
39	private File dest;
40
41	@Override
42	protected void setUp() throws Exception {
43	super.setUp();
44
45	removeFiles(new File(TasksUiPlugin.getDefault().getDataDirectory()));
46
47	// Create test export destination directory
48	dest = new File(TasksUiPlugin.getDefault().getDataDirectory() + File.separator + "TestDir");
49	if (dest.exists()) {
50	removeFiles(dest);
51	} else {
52	dest.mkdir();
53	}
54	assertTrue(dest.exists());
55	}
56
57	@Override
58	protected void tearDown() throws Exception {
59	super.tearDown();
60
61	removeFiles(dest);
62	dest.delete();
63	assertFalse(dest.exists());
64	}
65
66	public void testExportImportQuery() {
67	List<AbstractTaskListFactory> externalizers = new ArrayList<AbstractTaskListFactory>();
68	externalizers.add(new MockTaskListFactory());
69	TasksUiPlugin.getTaskListManager().getTaskListWriter().setDelegateExternalizers(externalizers);
70
71	MockRepositoryQuery query = new MockRepositoryQuery("Test Query");
72
73	File outFile = new File(dest, "test-query.xml.zip");
74
75	TasksUiPlugin.getTaskListManager().getTaskListWriter().writeQuery(query, outFile);
76	assertTrue(outFile.exists());
77
78	TaskList taskList = TasksUiPlugin.getTaskListManager().resetTaskList();
79
80	File inFile = new File(dest, "test-query.xml.zip");
81	TasksUiPlugin.getTaskListManager().getTaskListWriter().readQueries(taskList, inFile);
82	Set<AbstractRepositoryQuery> queries = taskList.getQueries();
83	assertEquals("1 Query is imported", 1, queries.size());
84	}
85
86
87
88	private void removeFiles(File root) {
89	if (root.isDirectory()) {
90	for (File file : root.listFiles()) {
91	if (file.isDirectory()) {
92	removeFiles(file);
93	}
94	file.delete();
95	}
96	}
97	}
98
99	}