Attachment #35860 for bug #84457

View | Details | Raw Unified | Return to bug 84457
Collapse All | Expand All

Lines 10-15 Link Here

(-)src/org/eclipse/ui/cheatsheets/ICheatSheetManager.java (+18 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.ui.cheatsheets;	11	package org.eclipse.ui.cheatsheets;
12		12
		13	import java.util.Set;
		14
13	/**	15	/**
14	* Manages the running of a cheat sheet.	16	* Manages the running of a cheat sheet.
15	* <p>	17	* <p>
Lines 68-71 Link Here
68	* is <code>null</code>	70	* is <code>null</code>
69	*/	71	*/
70	public void setData(String key, String data);	72	public void setData(String key, String data);
		73
		74	/**
		75	* Get the cheat sheet manager for the enclosing composite cheat sheet.
		76	* @return The cheat sheet manager for the composite cheat sheet which contains
		77	* this cheat sheet as a task or <code>null</code> if this cheatsheet was not
		78	* opened as a subtask of a composite cheat sheet.
		79	* @since 3.2
		80	*/
		81	public ICheatSheetManager getParent();
		82
		83	/**
		84	* Get the keys for the data in this cheat sheet manager
		85	* @return The set of keys.
		86	* @since 3.2
		87	*/
		88	public Set getKeySet();
71	}	89	}

Lines 11-16 Link Here

(-)src/org/eclipse/ui/cheatsheets/ICheatSheetViewer.java (+12 lines)
11	package org.eclipse.ui.cheatsheets;	11	package org.eclipse.ui.cheatsheets;
12		12
13	import java.net.URL;	13	import java.net.URL;
		14	import java.util.Map;
		15
14	import org.eclipse.swt.widgets.Composite;	16	import org.eclipse.swt.widgets.Composite;
15	import org.eclipse.swt.widgets.Control;	17	import org.eclipse.swt.widgets.Control;
16		18
Lines 113-116 Link Here
113	* are <code>null</code>	115	* are <code>null</code>
114	*/	116	*/
115	public void setInput(String id, String name, URL url);	117	public void setInput(String id, String name, URL url);
		118
		119	/**
		120	* Sets the currently active cheat sheet to its initial state and
		121	* initalizes the cheat sheet manager data.
		122	* @param cheatSheetData A map whose keys and values are all of type
		123	* <code>java.lang.String</code> or <code>null</code> to reset all data in
		124	* the cheat sheet manager.
		125	* @since 3.2
		126	*/
		127	public void reset(Map cheatSheetData);
116	}	128	}




import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.internal.cheatsheets.data.CheatSheetSaveHelper;
import org.eclipse.ui.internal.cheatsheets.data.IParserTags;
import org.eclipse.ui.internal.cheatsheets.registry.CheatSheetElement;

	private CheatSheetElement element;
	private CheatSheetSaveHelper saveHelper = new CheatSheetSaveHelper();
	private Properties props;
	private ICheatSheetManager parentCsm;

	/**
	 * @param memento The memento which will be used to initialize the state. May be
	 * null to indicate that the state should be initialized.
	 */
	public MementoStateManager(IMemento memento, ICheatSheetManager parentCsm) {
		this.memento = memento;
		this.parentCsm = parentCsm;
	}

	/**

		if (getProperties() != null) {
		    result.setData((Hashtable) getProperties().get(IParserTags.MANAGERDATA));
		}
		result.setParent(parentCsm);
		return result;
	}


Lines 21-26 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/composite/model/AbstractTask.java (-1 / +2 lines)
21		21
22	import org.eclipse.ui.cheatsheets.ICompositeCheatSheet;	22	import org.eclipse.ui.cheatsheets.ICompositeCheatSheet;
23	import org.eclipse.ui.cheatsheets.ICompositeCheatSheetTask;	23	import org.eclipse.ui.cheatsheets.ICompositeCheatSheetTask;
		24	import org.eclipse.ui.cheatsheets.ITaskGroup;
24	import org.eclipse.ui.internal.cheatsheets.composite.parser.ITaskParseStrategy;	25	import org.eclipse.ui.internal.cheatsheets.composite.parser.ITaskParseStrategy;
25		26
26	/**	27	/**
Lines 205-211 Link Here
205	this.parent = parent;	206	this.parent = parent;
206	}	207	}
207		208
208	public TaskGroup getParent() {	209	public ITaskGroup getParent() {
209	return parent;	210	return parent;
210	}	211	}
211		212





import java.net.URL;
import java.util.Hashtable;
import java.util.Map;
import java.util.Observable;

import org.eclipse.ui.IMemento;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.cheatsheets.ICompositeCheatSheetTask;
import org.eclipse.ui.cheatsheets.ICompositeCheatSheet;
import org.eclipse.ui.cheatsheets.TaskEditor;
import org.eclipse.ui.internal.cheatsheets.data.ICheatSheet;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;


		if (task instanceof EditableTask) {
		    EditableTask editable = (EditableTask)task;
			editable.setState(ICompositeCheatSheetTask.NOT_STARTED);
			TaskEditor editor = editable.getEditor();
		    if (editor != null) {
		    	editor.setInput(editable, null);
		    }
		} else if (task instanceof TaskGroup) { 
			TaskGroup group = (TaskGroup)task;
		    ICompositeCheatSheetTask[] subtasks = group.getSubtasks();

		}
	}

	public void resetAllTasks(Map cheatSheetData) {
        if (manager != null) {
    		if (cheatSheetData == null) {
            	manager.setData(new Hashtable());
    		} else {
    			manager.setData(cheatSheetData);
    		}
        }
        saveHelper.clearTaskMementos();	
	    resetTask(getRootTask());





import org.eclipse.core.runtime.IStatus;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.internal.cheatsheets.CommandRunner;
import org.eclipse.ui.internal.cheatsheets.Messages;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
import org.w3c.dom.Node;

/**

		return true;
	}

	public IStatus execute(CheatSheetManager csm) {
		return new CommandRunner().executeCommand(this, csm);
	}


Lines 12-18 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/data/AbstractExecutable.java (-2 / +2 lines)
12	package org.eclipse.ui.internal.cheatsheets.data;	12	package org.eclipse.ui.internal.cheatsheets.data;
13		13
14	import org.eclipse.core.runtime.IStatus;	14	import org.eclipse.core.runtime.IStatus;
15	import org.eclipse.ui.cheatsheets.ICheatSheetManager;	15	import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
16	import org.w3c.dom.Node;	16	import org.w3c.dom.Node;
17		17
18	/**	18	/**
Lines 107-113 Link Here
107	* completes with a failure result, error status if an exception was thrown	107	* completes with a failure result, error status if an exception was thrown
108	* or the executable could not be initiated.	108	* or the executable could not be initiated.
109	*/	109	*/
110	public abstract IStatus execute(ICheatSheetManager csm);	110	public abstract IStatus execute(CheatSheetManager csm);
111		111
112	/**	112	/**
113	* @return true if this executable can have parameters	113	* @return true if this executable can have parameters





import org.eclipse.core.runtime.IStatus;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.internal.cheatsheets.ActionRunner;
import org.eclipse.ui.internal.cheatsheets.Messages;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
import org.w3c.dom.Node;

/**

	}


	public IStatus execute(CheatSheetManager csm) {
		return new ActionRunner().runAction(this, csm);
	}





import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.cheatsheets.ICheatSheetAction;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.internal.cheatsheets.data.Action;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
import org.osgi.framework.Bundle;

/**
 * Class which can run actions and determine the outcome
 */
public class ActionRunner {
	public IStatus runAction(Action cheatSheetAction, CheatSheetManager csm) {

		IStatus status =  Status.OK_STATUS;
		String pluginId = cheatSheetAction.getPluginID();

					String param = clonedParams[i];
					if(param != null && param.startsWith("${") && param.endsWith("}")) { //$NON-NLS-1$ //$NON-NLS-2$
						param = param.substring(2,param.length()-1);
						String value = csm.getDataQualified(param);
						clonedParams[i] = value == null ? ICheatSheetResource.EMPTY_STRING : value;
					}
				}




import org.eclipse.osgi.util.NLS;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.internal.cheatsheets.data.CheatSheetCommand;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;

	 * @return OK_STATUS if the command completes withour error, otherwise
	 * an error status
	 */
	public IStatus executeCommand(CheatSheetCommand command, CheatSheetManager csm) {
		ICommandService service = getCommandService();
		if (service == null) {
			return new Status

		Object result;			
		String rawSerialization = command.getSerialization();
		try {
			String substitutedSerialization = csm.performVariableSubstitution(rawSerialization);
			    (rawSerialization, csm);
			selectedCommand = service.deserialize(substitutedSerialization);
			result = selectedCommand.executeWithChecks(null, null);
			

				ParameterType returnType = selectedCommand.getCommand().getReturnType();
				if ((returnType != null && (returnType.getValueConverter() != null))) {
					String resultString = returnType.getValueConverter().convertToString(result);
					csm.setDataQualified(returnsAttribute, resultString);
				}
				else {
					if (result instanceof String) {
						csm.setDataQualified(returnsAttribute, (String)result);
					}
				}
			}




		Dictionary params = task.getParameters();
		String id = (String)params.get(ICompositeCheatsheetTags.CHEATSHEET_TASK_ID);
		String path = (String)params.get(ICompositeCheatsheetTags.CHEATSHEET_TASK_PATH);
		MementoStateManager stateManager = new MementoStateManager(memento, task.getCompositeCheatSheet().getCheatSheetManager());
		if (path != null) {
			URL url;
			try {
				url = task.getInputUrl(path);
				if (id == null) { 
					id = task.getId();
				}
				viewer.setInput(id, task.getName(), url, stateManager);				
			} catch (MalformedURLException e) {
				e.printStackTrace();

		    viewer.setInput(id, stateManager);
		}
		viewer.addListener(new TaskListener());
		if (memento == null) {
			viewer.restart();
		}
	}
	
	/*





package org.eclipse.ui.internal.cheatsheets.composite.views;

import java.util.Map;
import java.util.Observable;
import java.util.Observer;


	}

	private void showTaskEditor(EditableTask task) {
		startIfSelected(task, false);
		TaskEditor editor = getTaskEditor(task, false);
		if (editor != null) {
		    setCurrentEditor(editor.getControl().getParent());
		}

	/*
	 * Ensure that if this task is visible and in a runnable state that it has been started
	 */
	private void startIfSelected(ICompositeCheatSheetTask task, boolean initialize) {
		if (task == selectedTask) {
			TaskEditor editor = getTaskEditor(task, initialize);
			if (editor!=null) {
				setCurrentEditor(editor.getControl());
			}

				if (data instanceof EditableTask) {
				    EditableTask task = (EditableTask)data;
				    task.setStarted();
				    startIfSelected(task, true);
				}
			}     
            if (ref.equals(SKIP_HREF)) {

	/*
	 * Get the task editor for this task. If no editor exists create one
	 */
	private TaskEditor getTaskEditor(ICompositeCheatSheetTask task, boolean initialize) {
		if (task instanceof EditableTask) {
			EditableTask editable = (EditableTask)task;
			if (editable.getEditor() == null) {

					editor.createControl(taskEditorContainer, mform.getToolkit());
					editor.setInput(editable, model.getTaskMemento(task.getId()));
					editable.setEditor(editor);
				} else if (initialize) {
					editor.setInput(editable, model.getTaskMemento(task.getId()));
				}
			}
			return editable.getEditor();
		}

							PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), 
							Messages.COMPOSITE_RESTART_DIALOG_TITLE, 
							Messages.COMPOSITE_RESTART_CONFIRM_MESSAGE)) {
					    restart(null);	
					    currentExplorer.setSelection
					        (new StructuredSelection(model.getRootTask()), true);	
				    }
				}
			}

		return index;
	}

	public void restart(Map cheatSheetData) {
		model.resetAllTasks(cheatSheetData);
		currentExplorer.setSelection
		    (new StructuredSelection(model.getRootTask()), true);
		
	}

}

Lines 17-22 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/views/CheatSheetViewer.java (-5 / +12 lines)
17	import java.util.Hashtable;	17	import java.util.Hashtable;
18	import java.util.Iterator;	18	import java.util.Iterator;
19	import java.util.ListIterator;	19	import java.util.ListIterator;
		20	import java.util.Map;
20	import java.util.Properties;	21	import java.util.Properties;
21	import java.util.StringTokenizer;	22	import java.util.StringTokenizer;
22		23
Lines 332-337 Link Here
332	private boolean loadState() {	333	private boolean loadState() {
333	try {	334	try {
334	Properties props = stateManager.getProperties();	335	Properties props = stateManager.getProperties();
		336
		337	manager = stateManager.getCheatSheetManager();
335		338
336	// There is a bug which causes the background of the buttons to	339	// There is a bug which causes the background of the buttons to
337	// remain white, even though the color is set. So instead of calling	340	// remain white, even though the color is set. So instead of calling
Lines 368-375 Link Here
368		371
369	if (cid != null)	372	if (cid != null)
370	currentID = cid;	373	currentID = cid;
371
372	manager = stateManager.getCheatSheetManager();
373		374
374	if (itemNum >= 0) {	375	if (itemNum >= 0) {
375	currentItemNum = itemNum;	376	currentItemNum = itemNum;
Lines 999-1007 Link Here
999		1000
1000	/package/ void setContent(CheatSheetElement element, ICheatSheetStateManager inputStateManager) {	1001	/package/ void setContent(CheatSheetElement element, ICheatSheetStateManager inputStateManager) {
1001	CheatSheetStopWatch.startStopWatch("CheatSheetViewer.setContent(CheatSheetElement element)"); //$NON-NLS-1$	1002	CheatSheetStopWatch.startStopWatch("CheatSheetViewer.setContent(CheatSheetElement element)"); //$NON-NLS-1$
1002
1003	if (element != null && element.equals(contentElement))
1004	return;
1005		1003
1006	// Cleanup previous contents	1004	// Cleanup previous contents
1007	internalDispose();	1005	internalDispose();
Lines 1170-1173 Link Here
1170	}	1168	}
1171	}	1169	}
1172		1170
		1171	public void reset(Map cheatSheetData) {
		1172	if (currentPage instanceof CheatSheetPage) {
		1173	restart();
		1174	getManager().setData(cheatSheetData);
		1175	} else if (currentPage instanceof CompositeCheatSheetPage) {
		1176	((CompositeCheatSheetPage)currentPage).restart(cheatSheetData);
		1177	}
		1178	}
		1179
1173	}	1180	}




 */
public class CheatSheetManager implements ICheatSheetManager {

	private static final String PARENT_PREFIX = "parent."; //$NON-NLS-1$
	private static final String VARIABLE_END = "}"; //$NON-NLS-1$
	private static final String VARIABLE_BEGIN = "${"; //$NON-NLS-1$
	private String cheatsheetID;
	private List listeners;
	private Map dataTable = null;
	private ICheatSheetManager parent;
	
	public CheatSheetManager(CheatSheetElement element) {
		cheatsheetID = element.getID();

			return null;
		return (String) dataTable.get(key);
	}
	
	/**
	 * Similar to get data except that if the key is prefixed with "parent."
	 * get the data from the parent
	 * @param qualifiedKey
	 * @return The data for this key
	 */
	public String getDataQualified(String qualifiedKey) {
		if (qualifiedKey.startsWith(PARENT_PREFIX) && parent != null) {
			return parent.getData(qualifiedKey.substring(PARENT_PREFIX.length()));
		} else {
			return getData(qualifiedKey);
		}
	}

	public String getVariableData(String variable) {
		String result = variable;
		if(variable != null && variable.startsWith(VARIABLE_BEGIN) && variable.endsWith(VARIABLE_END)) {
			result = variable.substring(2,variable.length()-1);
			result = getDataQualified(result);
		}
		return result;
	}
	
    /**
     * Substitute occurences of ${data} with values from the cheatsheetmanager.
     * This function is static to allow for JUnit testing
     * @param input The input string
     * @param csm The cheatsheet manager
     * @return The input string with substitutions made for any cheatsheet 
     * variables encountered.
     */
	public String performVariableSubstitution(String input)
			             ICheatSheetManager csm)
	{
		String remaining = input;
		String output = ""; //$NON-NLS-1$

			} else {
                String varName = remaining.substring(varIndex + VARIABLE_BEGIN.length(),
                		                         endIndex);
                String value = getDataQualified(varName);
                output += remaining.substring(0, varIndex);
                if (value != null) {
                	output += value;


		dataTable.put(key, data);
	}
	
	/**
	 * Similar to setData except that if the key is prefixed by "parent." 
	 * set the data in the parent.
	 * @param qualifiedKey A key which may be prefixed by parent.
	 * @param data The value to set
	 */
	public void setDataQualified(String qualifiedKey, String data) {
		if (qualifiedKey == null) {
			throw new IllegalArgumentException();
		}
		if (qualifiedKey.startsWith(PARENT_PREFIX) && parent != null) {
			parent.setData(qualifiedKey.substring(PARENT_PREFIX.length()), data);
		} else {
			setData(qualifiedKey, data);
		}
	}

	/**
	 * Add a listener for cheatsheet events

		    listeners.add(listener);
		}
	}

	public ICheatSheetManager getParent() {
		return parent;
	}
	
	public void setParent(ICheatSheetManager parent) {
		this.parent = parent;
	}

	public Set getKeySet() {
		if (dataTable == null) {
			return new HashSet();
		} else {
		    return dataTable.keySet();
		}
	}
}




import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.widgets.ImageHyperlink;

	}
	
	/*package*/
	IStatus runExecutable(CheatSheetManager csm) {
		return runExecutable(this.getItem().getExecutable(), csm);	
	}
	
	IStatus runExecutable(AbstractExecutable executable, CheatSheetManager csm) {
		if(executable != null) {
			return executable.execute(csm);
		} 

	 * this is the last step.
	 */
	void createCompletionComposite(boolean isFinalItem) {
		String completionMessage = viewer.getManager().performVariableSubstitution
		    (item.getCompletionMessage());
		if (completionMessage != null) {
			Color backgroundColor = bodyWrapperComposite.getBackground();
			completionComposite = page.getToolkit().createComposite(




/*******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.ua.tests.cheatsheet.execution;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.ui.cheatsheets.ICheatSheetManager;

/**
 * Mock object used in JUnit tests for command execution
 */

public class MockCheatSheetManager implements ICheatSheetManager {

	private Map dataStore = new HashMap();
	public String getCheatSheetID() {
		return "Mock";
	}

	public String getData(String key) {
		return (String)dataStore.get(key);
	}

	public void setData(String key, String data) {
		dataStore.put(key, data);
	}

}




import org.eclipse.core.runtime.IStatus;
import org.eclipse.ua.tests.plugin.UserAssistanceTestPlugin;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.cheatsheets.ICheatSheetManager;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.internal.cheatsheets.CommandRunner;
import org.eclipse.ui.internal.cheatsheets.data.CheatSheetCommand;
import org.eclipse.ui.internal.cheatsheets.registry.CheatSheetElement;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;

/**
 * Tests which exercise the CommandRunner class

	    + PARAM1_ID + '=' + PARAM1_VALUE + ',' 
	    + PARAM2_ID + '=' + PARAM2_VALUE + ')';	
	private static final String RETURN_STORE = "retData";
	private static final String PARENT_RETURN_STORE = "parent.retData";

	protected void setUp() throws Exception {
		CommandHandler.reset();
	}

	public CheatSheetManager createManager() {
		CheatSheetElement element = new CheatSheetElement("Name");
		element.setID("TestCommandExecutionId");
		return new CheatSheetManager(element);
	}
	
	private ICommandService getService() {
		IWorkbench wb =UserAssistanceTestPlugin.getDefault().getWorkbench(); //.getCommandSupport();

	
	public void testCommandRunner() {
		CheatSheetCommand command = new CheatSheetCommand();
		CheatSheetManager csm = createManager();
		command.setSerialization(SERIALIZED_COMMAND);
		
		IStatus status = new CommandRunner().executeCommand(command, csm);

		
		checkCommandExecution();
	}

	public void testCommandWithResult() {
		CheatSheetCommand command = new CheatSheetCommand();
		CheatSheetManager csm = createManager();
		command.setSerialization(SERIALIZED_COMMAND);
		command.setReturns(RETURN_STORE);
		

		checkCommandExecution();
	}
	
	/**
	 * Test that if the return is set to parent.retData the
	 * return value is written to the parent cheat sheet manager.
	 */
	public void testCommandWithQualifiedResult() {
		CheatSheetCommand command = new CheatSheetCommand();
		CheatSheetManager csm = createManager();
		CheatSheetManager parentManager = createManager();
		csm.setParent(parentManager);
		command.setSerialization(SERIALIZED_COMMAND);
		command.setReturns(PARENT_RETURN_STORE);
		
		IStatus status = new CommandRunner().executeCommand(command, csm);
		assertTrue(status.isOK());
		assertNull(csm.getData(RETURN_STORE));
		assertNotNull(parentManager.getData(RETURN_STORE));
	}
	
	public void testInvalidCommandId() {
		CheatSheetCommand command = new CheatSheetCommand();
		CheatSheetManager csm = createManager();
		command.setSerialization(COMMAND_ID + ".invalid");	 //$NON-NLS-1$
		IStatus status = new CommandRunner().executeCommand(command, csm);
		assertFalse(status.isOK());		

	
	public void testCommandException() {
		CheatSheetCommand command = new CheatSheetCommand();
		CheatSheetManager csm = createManager();
		command.setSerialization(SERIALIZED_COMMAND);
		CommandHandler.setThrowException(true);
		

	
	public void testCommandWithIntegerValues() {
		CheatSheetCommand command = new CheatSheetCommand();
		CheatSheetManager csm = createManager();
		command.setSerialization(NEGATE_INTEGER_COMMAND_ID);
		command.setReturns(INT_RETURN_STORE);
		




 * command execution
 */

import org.eclipse.ui.internal.cheatsheets.registry.CheatSheetElement;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;

import junit.framework.TestCase;

public class TestVariableSubstitution extends TestCase {
	private CheatSheetManager manager;
	
	protected void setUp() throws Exception {
		manager = new CheatSheetManager(new CheatSheetElement("name"));
		manager.setData("p1", "one");
		manager.setData("p2", "two");
	}
	
	private String substitute(String input) {
		return manager.performVariableSubstitution(input);
	}

	public void testNoSubstitution() {

Lines 23-28 Link Here

(-)cheatsheet/org/eclipse/ua/tests/cheatsheet/other/AllOtherCheatSheetTests.java (+1 lines)
23	TestSuite suite = new TestSuite(	23	TestSuite suite = new TestSuite(
24	"org.eclipse.ua.tests.cheatsheet.AllOtherCheatSheetTests");	24	"org.eclipse.ua.tests.cheatsheet.AllOtherCheatSheetTests");
25	//$JUnit-BEGIN$	25	//$JUnit-BEGIN$
		26	suite.addTestSuite(TestCheatSheetManager.class);
26	suite.addTestSuite(TestStatePersistence.class);	27	suite.addTestSuite(TestStatePersistence.class);
27	//$JUnit-END$	28	//$JUnit-END$
28	return suite;	29	return suite;




/*******************************************************************************
 * Copyright (c) 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.ua.tests.cheatsheet.other;

import java.util.Set;

import org.eclipse.ui.internal.cheatsheets.registry.CheatSheetElement;
import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;

import junit.framework.TestCase;

public class TestCheatSheetManager extends TestCase {

	private static final String CHEATSHEET_ID = "RandomId0234"; 
	private static final String CHEATSHEET_NAME = "Name"; 
	private static final String KEY1 = "key1";
	private static final String PARENT_KEY1 = "parent.key1";
	private static final String PARENT_KEY2 = "parent.key2";
	private static final String VALUE_A = "A";
	private static final String VALUE_B = "B";
	private static final String VALUE_C = "C";
	
	public CheatSheetManager createManager() {
		CheatSheetElement element = new CheatSheetElement(CHEATSHEET_NAME);
		element.setID(CHEATSHEET_ID);
		return new CheatSheetManager(element);
	}
	
	/**
	 * Test for correct initialization 
	 */
	public void testNewManager() {
		CheatSheetManager manager = createManager();
		assertNotNull(manager.getKeySet());
		assertTrue(manager.getKeySet().isEmpty());
		assertEquals(CHEATSHEET_ID, manager.getCheatSheetID());
	}
	
	/**
	 * Test that if there is no parent all references are local.
	 */
	public void testNoParent() {
		CheatSheetManager manager = createManager();
		manager.setDataQualified(KEY1, VALUE_A);
		manager.setDataQualified(PARENT_KEY1, VALUE_B);
		assertEquals(VALUE_A, manager.getData(KEY1));
		assertEquals(VALUE_A, manager.getDataQualified(KEY1));
		assertEquals(VALUE_B, manager.getData(PARENT_KEY1));
		assertEquals(VALUE_B, manager.getDataQualified(PARENT_KEY1));
		Set keys = manager.getKeySet();
		assertEquals(keys.size(), 2);
		assertTrue(keys.contains(KEY1));
		assertTrue(keys.contains(PARENT_KEY1));
	}
	
	/**
	 * Test that if there is a parent getDataQualified and setDataQualified
	 * can reference the parent but getData is always local
	 */
	public void testParentAccess() {
		CheatSheetManager manager = createManager();
		CheatSheetManager parentManager = createManager();
		manager.setParent(parentManager);
		manager.setDataQualified(KEY1, VALUE_A);
		manager.setDataQualified(PARENT_KEY1, VALUE_B);
		assertEquals(VALUE_A, manager.getData(KEY1));
		assertEquals(VALUE_A, manager.getDataQualified(KEY1));
		assertNull(manager.getData(PARENT_KEY1));
		assertEquals(VALUE_B, manager.getDataQualified(PARENT_KEY1));
		Set keys = manager.getKeySet();
		assertEquals(keys.size(), 1);
		assertTrue(keys.contains(KEY1));
		assertFalse(keys.contains(PARENT_KEY1));

		Set parentKeys = parentManager.getKeySet();
		assertEquals(parentKeys.size(), 1);
		assertTrue(parentKeys.contains(KEY1));
		assertFalse(parentKeys.contains(PARENT_KEY1));
	}
	
	/**
	 * Test that setData always writes locally
	 */
	public void testSetDataWithParent() {
		CheatSheetManager manager = createManager();
		CheatSheetManager parentManager = createManager();
		manager.setParent(parentManager);
		manager.setData(KEY1, VALUE_A);
		manager.setData(PARENT_KEY1, VALUE_B);
		assertEquals(VALUE_A, manager.getData(KEY1));
		assertEquals(VALUE_A, manager.getDataQualified(KEY1));
		assertNull(manager.getDataQualified(PARENT_KEY1));
		assertEquals(VALUE_B, manager.getData(PARENT_KEY1));
		Set keys = manager.getKeySet();
		assertEquals(keys.size(), 2);
		assertTrue(keys.contains(KEY1));
		assertTrue(keys.contains(PARENT_KEY1));

		Set parentKeys = parentManager.getKeySet();
		assertEquals(parentKeys.size(), 0);
	}
	
	public void testSubstitution() {
		CheatSheetManager manager = createManager();
		CheatSheetManager parentManager = createManager();
		manager.setParent(parentManager);
		manager.setDataQualified(KEY1, VALUE_A);
		manager.setDataQualified(PARENT_KEY1, VALUE_B);
		manager.setDataQualified(PARENT_KEY2, VALUE_C);
		assertEquals(VALUE_A, manager.getVariableData("${key1}"));
		assertEquals(VALUE_B, manager.getVariableData("${parent.key1}"));
		assertEquals(VALUE_C, manager.getVariableData("${parent.key2}"));
		assertEquals("Values are A B C", manager.performVariableSubstitution
				("Values are ${key1} ${parent.key1} ${parent.key2}"));
	}

}

Return to bug 84457

Lines 11-16 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/composite/views/CompositeCheatSheetPage.java (-10 / +18 lines)
11		11
12	package org.eclipse.ui.internal.cheatsheets.composite.views;	12	package org.eclipse.ui.internal.cheatsheets.composite.views;
13		13
		14	import java.util.Map;
14	import java.util.Observable;	15	import java.util.Observable;
15	import java.util.Observer;	16	import java.util.Observer;
16		17
Lines 279-286 Link Here
279	}	280	}
280		281
281	private void showTaskEditor(EditableTask task) {	282	private void showTaskEditor(EditableTask task) {
282	startIfSelected(task);	283	startIfSelected(task, false);
283	TaskEditor editor = getTaskEditor(task);	284	TaskEditor editor = getTaskEditor(task, false);
284	if (editor != null) {	285	if (editor != null) {
285	setCurrentEditor(editor.getControl().getParent());	286	setCurrentEditor(editor.getControl().getParent());
286	}	287	}
Lines 392-400 Link Here
392	/*	393	/*
393	* Ensure that if this task is visible and in a runnable state that it has been started	394	* Ensure that if this task is visible and in a runnable state that it has been started
394	*/	395	*/
395	private void startIfSelected(ICompositeCheatSheetTask task) {	396	private void startIfSelected(ICompositeCheatSheetTask task, boolean initialize) {
396	if (task == selectedTask) {	397	if (task == selectedTask) {
397	TaskEditor editor = getTaskEditor(task);	398	TaskEditor editor = getTaskEditor(task, initialize);
398	if (editor!=null) {	399	if (editor!=null) {
399	setCurrentEditor(editor.getControl());	400	setCurrentEditor(editor.getControl());
400	}	401	}
Lines 413-419 Link Here
413	if (data instanceof EditableTask) {	414	if (data instanceof EditableTask) {
414	EditableTask task = (EditableTask)data;	415	EditableTask task = (EditableTask)data;
415	task.setStarted();	416	task.setStarted();
416	startIfSelected(task);	417	startIfSelected(task, true);
417	}	418	}
418	}	419	}
419	if (ref.equals(SKIP_HREF)) {	420	if (ref.equals(SKIP_HREF)) {
Lines 520-526 Link Here
520	/*	521	/*
521	* Get the task editor for this task. If no editor exists create one	522	* Get the task editor for this task. If no editor exists create one
522	*/	523	*/
523	private TaskEditor getTaskEditor(ICompositeCheatSheetTask task) {	524	private TaskEditor getTaskEditor(ICompositeCheatSheetTask task, boolean initialize) {
524	if (task instanceof EditableTask) {	525	if (task instanceof EditableTask) {
525	EditableTask editable = (EditableTask)task;	526	EditableTask editable = (EditableTask)task;
526	if (editable.getEditor() == null) {	527	if (editable.getEditor() == null) {
Lines 530-536 Link Here
530	editor.createControl(taskEditorContainer, mform.getToolkit());	531	editor.createControl(taskEditorContainer, mform.getToolkit());
531	editor.setInput(editable, model.getTaskMemento(task.getId()));	532	editor.setInput(editable, model.getTaskMemento(task.getId()));
532	editable.setEditor(editor);	533	editable.setEditor(editor);
533	}	534	} else if (initialize) {
		535	editor.setInput(editable, model.getTaskMemento(task.getId()));
		536	}
534	}	537	}
535	return editable.getEditor();	538	return editable.getEditor();
536	}	539	}
Lines 569-577 Link Here
569	PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),	572	PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
570	Messages.COMPOSITE_RESTART_DIALOG_TITLE,	573	Messages.COMPOSITE_RESTART_DIALOG_TITLE,
571	Messages.COMPOSITE_RESTART_CONFIRM_MESSAGE)) {	574	Messages.COMPOSITE_RESTART_CONFIRM_MESSAGE)) {
572	model.resetAllTasks();	575	restart(null);
573	currentExplorer.setSelection
574	(new StructuredSelection(model.getRootTask()), true);
575	}	576	}
576	}	577	}
577	}	578	}
Lines 610-613 Link Here
610	return index;	611	return index;
611	}	612	}
612		613
		614	public void restart(Map cheatSheetData) {
		615	model.resetAllTasks(cheatSheetData);
		616	currentExplorer.setSelection
		617	(new StructuredSelection(model.getRootTask()), true);
		618
		619	}
		620
613	}	621	}

Lines 26-32 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/views/CoreItem.java (-5 / +4 lines)
26	import org.eclipse.swt.widgets.Control;	26	import org.eclipse.swt.widgets.Control;
27	import org.eclipse.swt.widgets.Label;	27	import org.eclipse.swt.widgets.Label;
28	import org.eclipse.ui.PlatformUI;	28	import org.eclipse.ui.PlatformUI;
29	import org.eclipse.ui.cheatsheets.ICheatSheetManager;
30	import org.eclipse.ui.forms.events.HyperlinkAdapter;	29	import org.eclipse.ui.forms.events.HyperlinkAdapter;
31	import org.eclipse.ui.forms.events.HyperlinkEvent;	30	import org.eclipse.ui.forms.events.HyperlinkEvent;
32	import org.eclipse.ui.forms.widgets.ImageHyperlink;	31	import org.eclipse.ui.forms.widgets.ImageHyperlink;
Lines 447-457 Link Here
447	}	446	}
448		447
449	/package/	448	/package/
450	IStatus runExecutable(ICheatSheetManager csm) {	449	IStatus runExecutable(CheatSheetManager csm) {
451	return runExecutable(this.getItem().getExecutable(), csm);	450	return runExecutable(this.getItem().getExecutable(), csm);
452	}	451	}
453		452
454	IStatus runExecutable(AbstractExecutable executable, ICheatSheetManager csm) {	453	IStatus runExecutable(AbstractExecutable executable, CheatSheetManager csm) {
455	if(executable != null) {	454	if(executable != null) {
456	return executable.execute(csm);	455	return executable.execute(csm);
457	}	456	}
Lines 540-547 Link Here
540	* this is the last step.	539	* this is the last step.
541	*/	540	*/
542	void createCompletionComposite(boolean isFinalItem) {	541	void createCompletionComposite(boolean isFinalItem) {
543	String completionMessage = CheatSheetManager.performVariableSubstitution	542	String completionMessage = viewer.getManager().performVariableSubstitution
544	(item.getCompletionMessage(), viewer.getManager());	543	(item.getCompletionMessage());
545	if (completionMessage != null) {	544	if (completionMessage != null) {
546	Color backgroundColor = bodyWrapperComposite.getBackground();	545	Color backgroundColor = bodyWrapperComposite.getBackground();
547	completionComposite = page.getToolkit().createComposite(	546	completionComposite = page.getToolkit().createComposite(

Lines 19-33 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/ActionRunner.java (-3 / +3 lines)
19	import org.eclipse.jface.util.PropertyChangeEvent;	19	import org.eclipse.jface.util.PropertyChangeEvent;
20	import org.eclipse.osgi.util.NLS;	20	import org.eclipse.osgi.util.NLS;
21	import org.eclipse.ui.cheatsheets.ICheatSheetAction;	21	import org.eclipse.ui.cheatsheets.ICheatSheetAction;
22	import org.eclipse.ui.cheatsheets.ICheatSheetManager;
23	import org.eclipse.ui.internal.cheatsheets.data.Action;	22	import org.eclipse.ui.internal.cheatsheets.data.Action;
		23	import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
24	import org.osgi.framework.Bundle;	24	import org.osgi.framework.Bundle;
25		25
26	/**	26	/**
27	* Class which can run actions and determine the outcome	27	* Class which can run actions and determine the outcome
28	*/	28	*/
29	public class ActionRunner {	29	public class ActionRunner {
30	public IStatus runAction(Action cheatSheetAction, ICheatSheetManager csm) {	30	public IStatus runAction(Action cheatSheetAction, CheatSheetManager csm) {
31		31
32	IStatus status = Status.OK_STATUS;	32	IStatus status = Status.OK_STATUS;
33	String pluginId = cheatSheetAction.getPluginID();	33	String pluginId = cheatSheetAction.getPluginID();
Lines 78-84 Link Here
78	String param = clonedParams[i];	78	String param = clonedParams[i];
79	if(param != null && param.startsWith("${") && param.endsWith("}")) { //$NON-NLS-1$ //$NON-NLS-2$	79	if(param != null && param.startsWith("${") && param.endsWith("}")) { //$NON-NLS-1$ //$NON-NLS-2$
80	param = param.substring(2,param.length()-1);	80	param = param.substring(2,param.length()-1);
81	String value = csm.getData(param);	81	String value = csm.getDataQualified(param);
82	clonedParams[i] = value == null ? ICheatSheetResource.EMPTY_STRING : value;	82	clonedParams[i] = value == null ? ICheatSheetResource.EMPTY_STRING : value;
83	}	83	}
84	}	84	}

Lines 47-57 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/composite/views/CheatsheetTaskEditor.java (-4 / +4 lines)
47	Dictionary params = task.getParameters();	47	Dictionary params = task.getParameters();
48	String id = (String)params.get(ICompositeCheatsheetTags.CHEATSHEET_TASK_ID);	48	String id = (String)params.get(ICompositeCheatsheetTags.CHEATSHEET_TASK_ID);
49	String path = (String)params.get(ICompositeCheatsheetTags.CHEATSHEET_TASK_PATH);	49	String path = (String)params.get(ICompositeCheatsheetTags.CHEATSHEET_TASK_PATH);
50	MementoStateManager stateManager = new MementoStateManager(memento);	50	MementoStateManager stateManager = new MementoStateManager(memento, task.getCompositeCheatSheet().getCheatSheetManager());
51	if (path != null) {	51	if (path != null) {
52	URL url;	52	URL url;
53	try {	53	try {
54	url = task.getInputUrl(path);	54	url = task.getInputUrl(path);
		55	if (id == null) {
		56	id = task.getId();
		57	}
55	viewer.setInput(id, task.getName(), url, stateManager);	58	viewer.setInput(id, task.getName(), url, stateManager);
56	} catch (MalformedURLException e) {	59	} catch (MalformedURLException e) {
57	e.printStackTrace();	60	e.printStackTrace();
Lines 61-69 Link Here
61	viewer.setInput(id, stateManager);	64	viewer.setInput(id, stateManager);
62	}	65	}
63	viewer.addListener(new TaskListener());	66	viewer.addListener(new TaskListener());
64	if (memento == null) {
65	viewer.restart();
66	}
67	}	67	}
68		68
69	/*	69	/*

Lines 20-30 Link Here

(-)src/org/eclipse/ui/internal/cheatsheets/views/CheatSheetManager.java (-5 / +52 lines)
20	*/	20	*/
21	public class CheatSheetManager implements ICheatSheetManager {	21	public class CheatSheetManager implements ICheatSheetManager {
22		22
		23	private static final String PARENT_PREFIX = "parent."; //$NON-NLS-1$
23	private static final String VARIABLE_END = "}"; //$NON-NLS-1$	24	private static final String VARIABLE_END = "}"; //$NON-NLS-1$
24	private static final String VARIABLE_BEGIN = "${"; //$NON-NLS-1$	25	private static final String VARIABLE_BEGIN = "${"; //$NON-NLS-1$
25	private String cheatsheetID;	26	private String cheatsheetID;
26	private List listeners;	27	private List listeners;
27	private Map dataTable = null;	28	private Map dataTable = null;
		29	private ICheatSheetManager parent;
28		30
29	public CheatSheetManager(CheatSheetElement element) {	31	public CheatSheetManager(CheatSheetElement element) {
30	cheatsheetID = element.getID();	32	cheatsheetID = element.getID();
Lines 71-96 Link Here
71	return null;	73	return null;
72	return (String) dataTable.get(key);	74	return (String) dataTable.get(key);
73	}	75	}
		76
		77	/**
		78	* Similar to get data except that if the key is prefixed with "parent."
		79	* get the data from the parent
		80	* @param qualifiedKey
		81	* @return The data for this key
		82	*/
		83	public String getDataQualified(String qualifiedKey) {
		84	if (qualifiedKey.startsWith(PARENT_PREFIX) && parent != null) {
		85	return parent.getData(qualifiedKey.substring(PARENT_PREFIX.length()));
		86	} else {
		87	return getData(qualifiedKey);
		88	}
		89	}
74		90
75	public String getVariableData(String variable) {	91	public String getVariableData(String variable) {
76	String result = variable;	92	String result = variable;
77	if(variable != null && variable.startsWith(VARIABLE_BEGIN) && variable.endsWith(VARIABLE_END)) {	93	if(variable != null && variable.startsWith(VARIABLE_BEGIN) && variable.endsWith(VARIABLE_END)) {
78	result = variable.substring(2,variable.length()-1);	94	result = variable.substring(2,variable.length()-1);
79	result = getData(result);	95	result = getDataQualified(result);
80	}	96	}
81	return result;	97	return result;
82	}	98	}
83		99
84	/**	100	/**
85	* Substitute occurences of ${data} with values from the cheatsheetmanager.	101	* Substitute occurences of ${data} with values from the cheatsheetmanager.
86	* This function is static to allow for JUnit testing
87	* @param input The input string	102	* @param input The input string
88	* @param csm The cheatsheet manager	103	* @param csm The cheatsheet manager
89	* @return The input string with substitutions made for any cheatsheet	104	* @return The input string with substitutions made for any cheatsheet
90	* variables encountered.	105	* variables encountered.
91	*/	106	*/
92	public static String performVariableSubstitution(String input,	107	public String performVariableSubstitution(String input)
93	ICheatSheetManager csm)
94	{	108	{
95	String remaining = input;	109	String remaining = input;
96	String output = ""; //$NON-NLS-1$	110	String output = ""; //$NON-NLS-1$
Lines 103-109 Link Here
103	} else {	117	} else {
104	String varName = remaining.substring(varIndex + VARIABLE_BEGIN.length(),	118	String varName = remaining.substring(varIndex + VARIABLE_BEGIN.length(),
105	endIndex);	119	endIndex);
106	String value = csm.getData(varName);	120	String value = getDataQualified(varName);
107	output += remaining.substring(0, varIndex);	121	output += remaining.substring(0, varIndex);
108	if (value != null) {	122	if (value != null) {
109	output += value;	123	output += value;
Lines 137-142 Link Here
137		151
138	dataTable.put(key, data);	152	dataTable.put(key, data);
139	}	153	}
		154
		155	/**
		156	* Similar to setData except that if the key is prefixed by "parent."
		157	* set the data in the parent.
		158	* @param qualifiedKey A key which may be prefixed by parent.
		159	* @param data The value to set
		160	*/
		161	public void setDataQualified(String qualifiedKey, String data) {
		162	if (qualifiedKey == null) {
		163	throw new IllegalArgumentException();
		164	}
		165	if (qualifiedKey.startsWith(PARENT_PREFIX) && parent != null) {
		166	parent.setData(qualifiedKey.substring(PARENT_PREFIX.length()), data);
		167	} else {
		168	setData(qualifiedKey, data);
		169	}
		170	}
140		171
141	/**	172	/**
142	* Add a listener for cheatsheet events	173	* Add a listener for cheatsheet events
Lines 147-150 Link Here
147	listeners.add(listener);	178	listeners.add(listener);
148	}	179	}
149	}	180	}
		181
		182	public ICheatSheetManager getParent() {
		183	return parent;
		184	}
		185
		186	public void setParent(ICheatSheetManager parent) {
		187	this.parent = parent;
		188	}
		189
		190	public Set getKeySet() {
		191	if (dataTable == null) {
		192	return new HashSet();
		193	} else {
		194	return dataTable.keySet();
		195	}
		196	}
150	}	197	}

Removed Link Here

(-)cheatsheet/org/eclipse/ua/tests/cheatsheet/execution/MockCheatSheetManager.java (-38 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.ua.tests.cheatsheet.execution;
13
14	import java.util.HashMap;
15	import java.util.Map;
16
17	import org.eclipse.ui.cheatsheets.ICheatSheetManager;
18
19	/**
20	* Mock object used in JUnit tests for command execution
21	*/
22
23	public class MockCheatSheetManager implements ICheatSheetManager {
24
25	private Map dataStore = new HashMap();
26	public String getCheatSheetID() {
27	return "Mock";
28	}
29
30	public String getData(String key) {
31	return (String)dataStore.get(key);
32	}
33
34	public void setData(String key, String data) {
35	dataStore.put(key, data);
36	}
37
38	}

Lines 16-37 Link Here

(-)cheatsheet/org/eclipse/ua/tests/cheatsheet/execution/TestVariableSubstitution.java (-4 / +4 lines)
16	* command execution	16	* command execution
17	*/	17	*/
18		18
19	import org.eclipse.ui.cheatsheets.ICheatSheetManager;	19	import org.eclipse.ui.internal.cheatsheets.registry.CheatSheetElement;
20	import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;	20	import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
21		21
22	import junit.framework.TestCase;	22	import junit.framework.TestCase;
23		23
24	public class TestVariableSubstitution extends TestCase {	24	public class TestVariableSubstitution extends TestCase {
25	private ICheatSheetManager manager;	25	private CheatSheetManager manager;
26		26
27	protected void setUp() throws Exception {	27	protected void setUp() throws Exception {
28	manager = new MockCheatSheetManager();	28	manager = new CheatSheetManager(new CheatSheetElement("name"));
29	manager.setData("p1", "one");	29	manager.setData("p1", "one");
30	manager.setData("p2", "two");	30	manager.setData("p2", "two");
31	}	31	}
32		32
33	private String substitute(String input) {	33	private String substitute(String input) {
34	return CheatSheetManager.performVariableSubstitution(input, manager);	34	return manager.performVariableSubstitution(input);
35	}	35	}
36		36
37	public void testNoSubstitution() {	37	public void testNoSubstitution() {

Added Link Here

(-)cheatsheet/org/eclipse/ua/tests/cheatsheet/other/TestCheatSheetManager.java (+126 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 IBM Corporation 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	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.ua.tests.cheatsheet.other;
13
14	import java.util.Set;
15
16	import org.eclipse.ui.internal.cheatsheets.registry.CheatSheetElement;
17	import org.eclipse.ui.internal.cheatsheets.views.CheatSheetManager;
18
19	import junit.framework.TestCase;
20
21	public class TestCheatSheetManager extends TestCase {
22
23	private static final String CHEATSHEET_ID = "RandomId0234";
24	private static final String CHEATSHEET_NAME = "Name";
25	private static final String KEY1 = "key1";
26	private static final String PARENT_KEY1 = "parent.key1";
27	private static final String PARENT_KEY2 = "parent.key2";
28	private static final String VALUE_A = "A";
29	private static final String VALUE_B = "B";
30	private static final String VALUE_C = "C";
31
32	public CheatSheetManager createManager() {
33	CheatSheetElement element = new CheatSheetElement(CHEATSHEET_NAME);
34	element.setID(CHEATSHEET_ID);
35	return new CheatSheetManager(element);
36	}
37
38	/**
39	* Test for correct initialization
40	*/
41	public void testNewManager() {
42	CheatSheetManager manager = createManager();
43	assertNotNull(manager.getKeySet());
44	assertTrue(manager.getKeySet().isEmpty());
45	assertEquals(CHEATSHEET_ID, manager.getCheatSheetID());
46	}
47
48	/**
49	* Test that if there is no parent all references are local.
50	*/
51	public void testNoParent() {
52	CheatSheetManager manager = createManager();
53	manager.setDataQualified(KEY1, VALUE_A);
54	manager.setDataQualified(PARENT_KEY1, VALUE_B);
55	assertEquals(VALUE_A, manager.getData(KEY1));
56	assertEquals(VALUE_A, manager.getDataQualified(KEY1));
57	assertEquals(VALUE_B, manager.getData(PARENT_KEY1));
58	assertEquals(VALUE_B, manager.getDataQualified(PARENT_KEY1));
59	Set keys = manager.getKeySet();
60	assertEquals(keys.size(), 2);
61	assertTrue(keys.contains(KEY1));
62	assertTrue(keys.contains(PARENT_KEY1));
63	}
64
65	/**
66	* Test that if there is a parent getDataQualified and setDataQualified
67	* can reference the parent but getData is always local
68	*/
69	public void testParentAccess() {
70	CheatSheetManager manager = createManager();
71	CheatSheetManager parentManager = createManager();
72	manager.setParent(parentManager);
73	manager.setDataQualified(KEY1, VALUE_A);
74	manager.setDataQualified(PARENT_KEY1, VALUE_B);
75	assertEquals(VALUE_A, manager.getData(KEY1));
76	assertEquals(VALUE_A, manager.getDataQualified(KEY1));
77	assertNull(manager.getData(PARENT_KEY1));
78	assertEquals(VALUE_B, manager.getDataQualified(PARENT_KEY1));
79	Set keys = manager.getKeySet();
80	assertEquals(keys.size(), 1);
81	assertTrue(keys.contains(KEY1));
82	assertFalse(keys.contains(PARENT_KEY1));
83
84	Set parentKeys = parentManager.getKeySet();
85	assertEquals(parentKeys.size(), 1);
86	assertTrue(parentKeys.contains(KEY1));
87	assertFalse(parentKeys.contains(PARENT_KEY1));
88	}
89
90	/**
91	* Test that setData always writes locally
92	*/
93	public void testSetDataWithParent() {
94	CheatSheetManager manager = createManager();
95	CheatSheetManager parentManager = createManager();
96	manager.setParent(parentManager);
97	manager.setData(KEY1, VALUE_A);
98	manager.setData(PARENT_KEY1, VALUE_B);
99	assertEquals(VALUE_A, manager.getData(KEY1));
100	assertEquals(VALUE_A, manager.getDataQualified(KEY1));
101	assertNull(manager.getDataQualified(PARENT_KEY1));
102	assertEquals(VALUE_B, manager.getData(PARENT_KEY1));
103	Set keys = manager.getKeySet();
104	assertEquals(keys.size(), 2);
105	assertTrue(keys.contains(KEY1));
106	assertTrue(keys.contains(PARENT_KEY1));
107
108	Set parentKeys = parentManager.getKeySet();
109	assertEquals(parentKeys.size(), 0);
110	}
111
112	public void testSubstitution() {
113	CheatSheetManager manager = createManager();
114	CheatSheetManager parentManager = createManager();
115	manager.setParent(parentManager);
116	manager.setDataQualified(KEY1, VALUE_A);
117	manager.setDataQualified(PARENT_KEY1, VALUE_B);
118	manager.setDataQualified(PARENT_KEY2, VALUE_C);
119	assertEquals(VALUE_A, manager.getVariableData("${key1}"));
120	assertEquals(VALUE_B, manager.getVariableData("${parent.key1}"));
121	assertEquals(VALUE_C, manager.getVariableData("${parent.key2}"));
122	assertEquals("Values are A B C", manager.performVariableSubstitution
123	("Values are ${key1} ${parent.key1} ${parent.key2}"));
124	}
125
126	}