| /******************************************************************************* |
| * 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.ui.tests.commands; |
| |
| import org.eclipse.core.commands.Command; |
| import org.eclipse.core.commands.IParameter; |
| import org.eclipse.core.commands.ITypedParameter; |
| import org.eclipse.core.commands.ParameterType; |
| import org.eclipse.core.commands.ParameterValueConversionException; |
| import org.eclipse.core.commands.Parameterization; |
| import org.eclipse.core.commands.ParameterizedCommand; |
| import org.eclipse.core.commands.common.CommandException; |
| import org.eclipse.ui.commands.ICommandService; |
| import org.eclipse.ui.tests.harness.util.UITestCase; |
| |
| public class CommandParameterTypeTest extends UITestCase { |
| |
| static final String SUBTRACT = "org.eclipse.ui.tests.commands.subtractInteger"; |
| static final String MINUEND = "minuend"; |
| static final String SUBTRAHEND = "subtrahend"; |
| |
| static final String TYPE = "org.eclipse.ui.tests.commands.Integer"; |
| |
| /** |
| * Constructs a new instance of <code>CommandParameterTypeTest</code>. |
| * |
| * @param name |
| * The name of the test |
| */ |
| public CommandParameterTypeTest(String testName) { |
| super(testName); |
| } |
| |
| /** |
| * Tests invoking a command that subtracts one number from another. The |
| * handler for the subtract command will convert the string parameters to |
| * integers to perform the operation. This test drives much of the command |
| * parameter type infrastructure including obtaining parameter types and |
| * performing stringToObject and objectToString conversions. |
| */ |
| public void testSubtract() throws CommandException { |
| testSubtract(8, 5, 3); |
| testSubtract(-4, 12, -16); |
| } |
| |
| /** |
| * Test subtract again with invalid parameters and check for failure |
| * exception. |
| */ |
| public void testSubtractTypeError() { |
| try { |
| // try to pass a Boolean instead of an Integer |
| testSubtract(new Integer(3), Boolean.FALSE, 3); |
| fail("expected ParameterValueConversionException"); |
| } |
| catch (ParameterValueConversionException ex) { |
| // passed |
| } |
| catch (Exception ex) { |
| fail("expected ParameterValueConversionException"); |
| } |
| } |
| |
| /** |
| * Test the complete execution flow for the subtract command |
| */ |
| private void testSubtract(int minuend, int subtrahend, int difference) throws CommandException { |
| testSubtract(new Integer(minuend), new Integer(subtrahend), difference); |
| } |
| |
| /** |
| * Test the complete execution flow for the subtract command |
| */ |
| private void testSubtract(Object minuend, Object subtrahend, int difference) throws CommandException { |
| ICommandService commandService = getCommandService(); |
| Command command = commandService.getCommand(SUBTRACT); |
| |
| // first convert the object params to strings |
| String minuendStr = command.getParameterType(MINUEND) |
| .getValueConverter().convertToString(minuend); |
| String subtrahendStr = command.getParameterType(SUBTRAHEND) |
| .getValueConverter().convertToString(subtrahend); |
| |
| // setup the parameterizations |
| Parameterization minuendParam = new Parameterization(command |
| .getParameter(MINUEND), minuendStr); |
| Parameterization subtrahendParam = new Parameterization(command |
| .getParameter(SUBTRAHEND), subtrahendStr); |
| Parameterization[] parameterizations = new Parameterization[] { |
| minuendParam, subtrahendParam }; |
| |
| // execute the command and check the result |
| ParameterizedCommand pCommand = new ParameterizedCommand(command, |
| parameterizations); |
| Integer result = (Integer) pCommand.executeWithChecks(null, null); |
| assertEquals(difference, result.intValue()); |
| } |
| |
| /** |
| * Tests AbstractParameterValueConverter.convertToObject for the Integer |
| * converter used in this test suite. |
| */ |
| public void testConvertStringToInteger() throws CommandException { |
| testConvertStringToInteger("33", 33, false); |
| testConvertStringToInteger("-1", -1, false); |
| testConvertStringToInteger("blah", 33, true); |
| testConvertStringToInteger(null, 33, true); |
| } |
| |
| private void testConvertStringToInteger(String value, int expected, |
| boolean expectFail) throws CommandException { |
| ICommandService commandService = getCommandService(); |
| ParameterType type = commandService.getParameterType(TYPE); |
| |
| Object converted = null; |
| if (expectFail) { |
| try { |
| converted = type.getValueConverter().convertToObject(value); |
| fail("expected ParameterValueConversionException"); |
| } catch (ParameterValueConversionException ex) { |
| // passed |
| return; |
| } catch (Exception ex) { |
| fail("expected ParameterValueConversionException"); |
| } |
| } else { |
| converted = type.getValueConverter().convertToObject(value); |
| } |
| |
| assertEquals(new Integer(expected), converted); |
| } |
| |
| /** |
| * Tests AbstractParameterValueConverter.convertToString for the Integer |
| * converter used in this test suite. |
| */ |
| public void testConvertIntegerToString() throws CommandException { |
| testConvertIntegerToString(new Integer(6), "6", false); |
| testConvertIntegerToString(new Integer(0), "0", false); |
| testConvertIntegerToString(new Integer(-32), "-32", false); |
| testConvertIntegerToString(null, null, true); |
| testConvertIntegerToString(Boolean.TRUE, null, true); |
| } |
| |
| private void testConvertIntegerToString(Object value, String expected, |
| boolean expectFail) throws CommandException { |
| ICommandService commandService = getCommandService(); |
| ParameterType type = commandService.getParameterType(TYPE); |
| |
| String converted = null; |
| if (expectFail) { |
| try { |
| converted = type.getValueConverter().convertToString(value); |
| fail("expected ParameterValueConversionException"); |
| } catch (ParameterValueConversionException ex) { |
| // passed |
| return; |
| } catch (Exception ex) { |
| fail("expected ParameterValueConversionException"); |
| } |
| } else { |
| converted = type.getValueConverter().convertToString(value); |
| } |
| assertEquals(expected, converted); |
| } |
| |
| /** |
| * Tests ParameterType.isCompatible for various values with the Integer |
| * parameter type used in this test suite. |
| */ |
| public void testIsCompatible() throws CommandException { |
| ICommandService commandService = getCommandService(); |
| ParameterType type = commandService.getParameterType(TYPE); |
| |
| assertTrue(type.isCompatible(new Integer(4))); |
| assertTrue(type.isCompatible(new Integer(0))); |
| assertTrue(type.isCompatible(new Integer(-434))); |
| assertFalse(type.isCompatible(null)); |
| assertFalse(type.isCompatible("4")); |
| } |
| |
| /** |
| * Try to find a command that takes integers as parameters. We might find |
| * multiple commands - just make sure we can at least find the subtract |
| * command used elsewhere in this test suite. |
| */ |
| public void testFindIntegerParamCommand() throws CommandException { |
| Integer value = new Integer(6); |
| |
| ICommandService commandService = getCommandService(); |
| Command[] commands = commandService.getDefinedCommands(); |
| |
| boolean foundSubtract = false; |
| |
| for (int i = 0; i < commands.length; i++) { |
| Command command = commands[i]; |
| if (!command.isDefined()) |
| continue; |
| |
| IParameter[] parameters = command.getParameters(); |
| if (parameters == null) |
| continue; |
| |
| if (parameters.length == 0) |
| continue; |
| |
| if (checkParamType1(command, parameters[0], value) |
| && checkParamType2(parameters[0], value)) { |
| if (SUBTRACT.equals(command.getId())) { |
| foundSubtract = true; |
| break; |
| } |
| } |
| } |
| |
| assertTrue(foundSubtract); |
| } |
| |
| private boolean checkParamType1(Command command, IParameter parameter, |
| Object value) throws CommandException { |
| ParameterType type = command.getParameterType(parameter.getId()); |
| if (type == null) |
| return false; |
| return type.isCompatible(value); |
| } |
| |
| private boolean checkParamType2(IParameter parameter, Object value) |
| throws CommandException { |
| if (!(parameter instanceof ITypedParameter)) |
| return false; |
| ParameterType type = ((ITypedParameter) parameter).getParameterType(); |
| if (type == null) |
| return false; |
| return type.isCompatible(value); |
| } |
| |
| |
| private ICommandService getCommandService() { |
| Object serviceObject = getWorkbench().getAdapter(ICommandService.class); |
| if (serviceObject != null) { |
| ICommandService service = (ICommandService) serviceObject; |
| return service; |
| } |
| return null; |
| } |
| } |