Merge branch 'develop' into feature/multiview

de.prob.units/build.properties

+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               icons/,\
+               plugin.xml

de.prob.units/plugin.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="org.eventb.ui.editorItems">
+      <textAttribute
+            class="de.prob.units.pragmas.UnitPragmaAttribute"
+            expandsHorizontally="true"
+            id="de.prob.units.unitPragmaAttribute"
+            isMath="true"
+            prefix="Physical Unit:"
+            style="de.prob.units.unitPragmaAttribute"
+            typeId="de.prob.units.unitPragmaAttribute">
+      </textAttribute>
+      <attributeRelation
+            elementTypeId="org.eventb.core.variable">
+         <attributeReference
+               descriptionId="de.prob.units.unitPragmaAttribute">
+         </attributeReference>
+         <attributeReference
+               descriptionId="de.prob.units.inferredUnitPragmaAttribute">
+         </attributeReference>
+      </attributeRelation>
+      <attributeRelation
+            elementTypeId="org.eventb.core.constant">
+         <attributeReference
+               descriptionId="de.prob.units.unitPragmaAttribute">
+         </attributeReference>
+         <attributeReference
+               descriptionId="de.prob.units.inferredUnitPragmaAttribute">
+         </attributeReference>
+      </attributeRelation>
+      <textAttribute
+            class="de.prob.units.pragmas.InferredUnitPragmaAttribute"
+            expandsHorizontally="true"
+            id="de.prob.units.inferredUnitPragmaAttribute"
+            isMath="true"
+            prefix="Inferred Physical Unit:"
+            style="de.prob.units.inferredUnitPragmaAttribute"
+            typeId="de.prob.units.inferredUnitPragmaAttribute">
+      </textAttribute>
+   </extension>
+   <extension
+         point="org.eclipse.ui.handlers">
+      <handler
+            class="de.prob.units.ui.StartUnitAnalysisHandler"
+            commandId="de.prob.units.startunitanalysis">
+      </handler>
+   </extension>
+   <extension
+         point="org.eclipse.ui.menus">
+      <menuContribution
+            locationURI="popup:fr.systerel.explorer.navigator.view">
+         <separator
+               name="de.prob.units.separator2"
+               visible="true">
+         </separator>
+         <command
+               commandId="de.prob.units.startunitanalysis"
+               icon="icons/unit_analysis.png"
+               label="Analyse Physical Units"
+               style="push">
+            <visibleWhen>
+               <with
+                     variable="selection">
+                  <iterate
+                        operator="or">
+                     <instanceof
+                           value="org.eventb.core.IEventBRoot">
+                     </instanceof>
+                  </iterate>
+               </with>
+            </visibleWhen>
+         </command>
+         <separator
+               name="de.prob.units.separator1"
+               visible="true">
+         </separator>
+      </menuContribution>
+   </extension>
+   <extension
+         point="org.eclipse.ui.commands">
+      <command
+            id="de.prob.units.startunitanalysis"
+            name="Analyse Physical Units">
+      </command>
+   </extension>
+   <extension
+         point="org.rodinp.core.attributeTypes">
+      <attributeType
+            id="unitPragmaAttribute"
+            kind="string"
+            name="Content of a unit Pragma to send to ProB">
+      </attributeType>
+      <attributeType
+            id="inferredUnitPragmaAttribute"
+            kind="string"
+            name="Content of a unit Pragma received from ProB">
+      </attributeType>
+   </extension>
+</plugin>

de.prob.units/src/de/prob/units/Activator.java

+package de.prob.units;
+
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The activator class controls the plug-in life cycle
+ */
+public class Activator extends AbstractUIPlugin {
+
+	// The plug-in ID
+	public static final String PLUGIN_ID = "de.prob.units"; //$NON-NLS-1$
+
+	// The shared instance
+	private static Activator plugin;
+	
+	/**
+	 * The constructor
+	 */
+	public Activator() {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
+	 */
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		plugin = this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
+	 */
+	public void stop(BundleContext context) throws Exception {
+		plugin = null;
+		super.stop(context);
+	}
+
+	/**
+	 * Returns the shared instance
+	 *
+	 * @return the shared instance
+	 */
+	public static Activator getDefault() {
+		return plugin;
+	}
+
+}

de.prob.units/src/de/prob/units/pragmas/InferredUnitPragmaAttribute.java

+/**
+ * (c) 2009 Lehrstuhl fuer Softwaretechnik und Programmiersprachen, Heinrich
+ * Heine Universitaet Duesseldorf This software is licenced under EPL 1.0
+ * (http://www.eclipse.org/org/documents/epl-v10.html)
+ * */
+
+package de.prob.units.pragmas;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eventb.core.IVariable;
+import org.eventb.core.basis.Constant;
+import org.eventb.internal.ui.eventbeditor.manipulation.IAttributeManipulation;
+import org.rodinp.core.IAttributeType;
+import org.rodinp.core.IInternalElement;
+import org.rodinp.core.IRodinElement;
+import org.rodinp.core.RodinCore;
+import org.rodinp.core.RodinDBException;
+
+import de.prob.units.Activator;
+
+public class InferredUnitPragmaAttribute implements IAttributeManipulation {
+	public static IAttributeType.String ATTRIBUTE = RodinCore
+			.getStringAttrType(Activator.PLUGIN_ID
+					+ ".inferredUnitPragmaAttribute");
+
+	public InferredUnitPragmaAttribute() {
+		// empty constructor
+	}
+
+	private IInternalElement asInternalElement(IRodinElement element) {
+		if (element instanceof IVariable) {
+			return (IVariable) element;
+		} else if (element instanceof Constant) {
+			return (Constant) element;
+		}
+		return null;
+	}
+
+	@Override
+	public String[] getPossibleValues(IRodinElement element,
+			IProgressMonitor monitor) {
+		return null;
+	}
+
+	@Override
+	public String getValue(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		return asInternalElement(element).getAttributeValue(ATTRIBUTE);
+	}
+
+	@Override
+	public boolean hasValue(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		return asInternalElement(element).hasAttribute(ATTRIBUTE);
+	}
+
+	@Override
+	public void removeAttribute(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		asInternalElement(element).removeAttribute(ATTRIBUTE, monitor);
+
+	}
+
+	@Override
+	public void setDefaultValue(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		asInternalElement(element).setAttributeValue(ATTRIBUTE, "", monitor);
+	}
+
+	@Override
+	public void setValue(IRodinElement element, String value,
+			IProgressMonitor monitor) throws RodinDBException {
+		asInternalElement(element).setAttributeValue(ATTRIBUTE, value, monitor);
+	}
+}

de.prob.units/src/de/prob/units/pragmas/UnitPragmaAttribute.java

+/**
+ * (c) 2009 Lehrstuhl fuer Softwaretechnik und Programmiersprachen, Heinrich
+ * Heine Universitaet Duesseldorf This software is licenced under EPL 1.0
+ * (http://www.eclipse.org/org/documents/epl-v10.html)
+ * */
+
+package de.prob.units.pragmas;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eventb.core.IVariable;
+import org.eventb.core.basis.Constant;
+import org.eventb.internal.ui.eventbeditor.manipulation.IAttributeManipulation;
+import org.rodinp.core.IAttributeType;
+import org.rodinp.core.IInternalElement;
+import org.rodinp.core.IRodinElement;
+import org.rodinp.core.RodinCore;
+import org.rodinp.core.RodinDBException;
+
+import de.prob.units.Activator;
+
+public class UnitPragmaAttribute implements IAttributeManipulation {
+	public static IAttributeType.String ATTRIBUTE = RodinCore
+			.getStringAttrType(Activator.PLUGIN_ID + ".unitPragmaAttribute");
+
+	public UnitPragmaAttribute() {
+		// empty constructor
+	}
+
+	private IInternalElement asInternalElement(IRodinElement element) {
+		if (element instanceof IVariable) {
+			return (IVariable) element;
+		} else if (element instanceof Constant) {
+			return (Constant) element;
+		}
+		return null;
+	}
+
+	@Override
+	public String[] getPossibleValues(IRodinElement element,
+			IProgressMonitor monitor) {
+		return null;
+	}
+
+	@Override
+	public String getValue(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		return asInternalElement(element).getAttributeValue(ATTRIBUTE);
+	}
+
+	@Override
+	public boolean hasValue(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		return asInternalElement(element).hasAttribute(ATTRIBUTE);
+	}
+
+	@Override
+	public void removeAttribute(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		asInternalElement(element).removeAttribute(ATTRIBUTE, monitor);
+
+	}
+
+	@Override
+	public void setDefaultValue(IRodinElement element, IProgressMonitor monitor)
+			throws RodinDBException {
+		asInternalElement(element).setAttributeValue(ATTRIBUTE, "", monitor);
+	}
+
+	@Override
+	public void setValue(IRodinElement element, String value,
+			IProgressMonitor monitor) throws RodinDBException {
+		asInternalElement(element).setAttributeValue(ATTRIBUTE, value, monitor);
+	}
+}

de.prob.units/src/de/prob/units/ui/StartUnitAnalysisHandler.java

+/**
+ * (c) 2009 Lehrstuhl fuer Softwaretechnik und Programmiersprachen, Heinrich
+ * Heine Universitaet Duesseldorf This software is licenced under EPL 1.0
+ * (http://www.eclipse.org/org/documents/epl-v10.html)
+ * */
+
+package de.prob.units.ui;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.core.commands.IHandler;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.handlers.HandlerUtil;
+import org.eventb.core.IConstant;
+import org.eventb.core.IContextRoot;
+import org.eventb.core.IEventBRoot;
+import org.eventb.core.IMachineRoot;
+import org.eventb.core.IVariable;
+import org.rodinp.core.IRodinFile;
+import org.rodinp.core.RodinCore;
+import org.rodinp.core.RodinDBException;
+
+import de.prob.core.Animator;
+import de.prob.core.LimitedLogger;
+import de.prob.core.command.ActivateUnitPluginCommand;
+import de.prob.core.command.ClearMachineCommand;
+import de.prob.core.command.CommandException;
+import de.prob.core.command.ComposedCommand;
+import de.prob.core.command.GetPluginResultCommand;
+import de.prob.core.command.SetPreferencesCommand;
+import de.prob.core.command.StartAnimationCommand;
+import de.prob.core.command.internal.InternalLoadCommand;
+import de.prob.exceptions.ProBException;
+import de.prob.logging.Logger;
+import de.prob.parser.BindingGenerator;
+import de.prob.parser.ResultParserException;
+import de.prob.prolog.term.CompoundPrologTerm;
+import de.prob.prolog.term.ListPrologTerm;
+import de.prob.prolog.term.PrologTerm;
+import de.prob.units.pragmas.InferredUnitPragmaAttribute;
+
+public class StartUnitAnalysisHandler extends AbstractHandler implements
+		IHandler {
+
+	public static class ModificationListener implements IResourceChangeListener {
+
+		private final IPath path;
+
+		public ModificationListener(final IFile resource) {
+			if (resource == null) {
+				path = null;
+			} else {
+				this.path = resource.getProject().getFullPath();
+			}
+		}
+
+		public void resourceChanged(final IResourceChangeEvent event) {
+			if (path != null) {
+				final IResourceDelta delta = event.getDelta();
+				IResourceDelta member = delta.findMember(path);
+				if (member != null) {
+					Animator.getAnimator().setDirty();
+				}
+			}
+		}
+	}
+
+	private ISelection fSelection;
+	private ModificationListener listener;
+
+	public Object execute(final ExecutionEvent event) throws ExecutionException {
+
+		fSelection = HandlerUtil.getCurrentSelection(event);
+
+		// Get the Selection
+		final IEventBRoot rootElement = getRootElement();
+		final IFile resource = extractResource(rootElement);
+
+		ArrayList<String> errors = new ArrayList<String>();
+		boolean realError = checkErrorMarkers(resource, errors);
+		if (!errors.isEmpty()) {
+			String message = "Some components in your project contain "
+					+ (realError ? "errors" : "warnings")
+					+ ". This can lead to unexpected behavior (e.g. missing variables) when animating.\n\nDetails:\n";
+			StringBuffer stringBuffer = new StringBuffer(message);
+			for (String string : errors) {
+				stringBuffer.append(string);
+				stringBuffer.append('\n');
+			}
+			if (realError)
+				Logger.notifyUserWithoutBugreport(stringBuffer.toString());
+			else
+				Logger.notifyUserAboutWarningWithoutBugreport(stringBuffer
+						.toString());
+		}
+		;
+
+		if (resource != null) {
+			LimitedLogger.getLogger().log("user started unit analysis",
+					rootElement.getElementName(), null);
+			registerModificationListener(resource);
+
+			final Animator animator = Animator.getAnimator();
+			try {
+				// load machine and activate plugin
+				final ClearMachineCommand clear = new ClearMachineCommand();
+				final SetPreferencesCommand setPrefs = SetPreferencesCommand
+						.createSetPreferencesCommand(animator);
+				final InternalLoadCommand load = new InternalLoadCommand(
+						rootElement);
+				final StartAnimationCommand start = new StartAnimationCommand();
+				final ActivateUnitPluginCommand activatePlugin = new ActivateUnitPluginCommand();
+
+				final ComposedCommand composed = new ComposedCommand(clear,
+						setPrefs, load, start, activatePlugin);
+
+				animator.execute(composed);
+
+				GetPluginResultCommand pluginResultCommand = new GetPluginResultCommand(
+						"Grounded Result State");
+
+				animator.execute(pluginResultCommand);
+
+				processResults(pluginResultCommand.getResult());
+			} catch (ProBException e) {
+				e.notifyUserOnce();
+				throw new ExecutionException("Unit Analysis Failed", e);
+			} catch (RodinDBException e) {
+				throw new ExecutionException(
+						"Unit Analysis Failed with a RodinDBException", e);
+			}
+		}
+		return null;
+	}
+
+	private boolean checkErrorMarkers(final IFile resource, List<String> errors) {
+		boolean result = false;
+		IProject project = resource.getProject();
+		try {
+			IMarker[] markers = project.findMarkers(
+					"org.eclipse.core.resources.problemmarker", true,
+					IResource.DEPTH_INFINITE);
+			for (IMarker iMarker : markers) {
+				errors.add(iMarker.getResource().getName()
+						+ ": "
+						+ iMarker
+								.getAttribute(IMarker.MESSAGE, "unknown Error"));
+				result = result
+						|| (Integer) iMarker.getAttribute(IMarker.SEVERITY) == IMarker.SEVERITY_ERROR;
+			}
+
+		} catch (CoreException e1) {
+		}
+		return result;
+	}
+
+	private void processResults(ListPrologTerm result) throws RodinDBException,
+			ExecutionException {
+		// preprocess the list into a map
+		Map<String, String> variables = new HashMap<String, String>();
+		for (PrologTerm term : result) {
+			CompoundPrologTerm compoundTerm;
+			try {
+				compoundTerm = BindingGenerator
+						.getCompoundTerm(term, "bind", 2);
+
+				variables.put(
+						PrologTerm.atomicString(compoundTerm.getArgument(1)),
+						PrologTerm.atomicString(compoundTerm.getArgument(2)));
+			} catch (ResultParserException e) {
+				CommandException commandException = new CommandException(
+						e.getLocalizedMessage(), e);
+				commandException.notifyUserOnce();
+			}
+		}
+
+		IEventBRoot rootElement = getRootElement();
+		// look up the variables / constants of the selected machine in
+		// the state
+		// and set the inferredUnitPragma attribute
+		if (rootElement instanceof IMachineRoot) {
+			// find and update variables
+			IVariable[] allVariables = rootElement.getMachineRoot()
+					.getVariables();
+
+			for (IVariable var : allVariables) {
+				String variableName = var.getIdentifierString();
+				if (variables.containsKey(variableName)) {
+					var.setAttributeValue(
+							InferredUnitPragmaAttribute.ATTRIBUTE,
+							variables.get(variableName),
+							new NullProgressMonitor());
+				}
+			}
+
+		} else if (rootElement instanceof IContextRoot) {
+			// find and update constants
+			IConstant[] allConstants = rootElement.getContextRoot()
+					.getConstants();
+
+			for (IConstant var : allConstants) {
+				String constantName = var.getIdentifierString();
+				if (variables.containsKey(constantName)) {
+					var.setAttributeValue(
+							InferredUnitPragmaAttribute.ATTRIBUTE,
+							variables.get(constantName),
+							new NullProgressMonitor());
+				}
+			}
+		} else {
+			throw new ExecutionException(
+					"Cannot execute unit analysis on this element type. Type of "
+							+ rootElement.getComponentName() + " was: "
+							+ rootElement.getClass());
+		}
+	}
+
+	private IEventBRoot getRootElement() {
+		IEventBRoot root = null;
+		if (fSelection instanceof IStructuredSelection) {
+			final IStructuredSelection ssel = (IStructuredSelection) fSelection;
+			if (ssel.size() == 1) {
+				final Object element = ssel.getFirstElement();
+				if (element instanceof IEventBRoot) {
+					root = (IEventBRoot) element;
+				} else if (element instanceof IFile) {
+					IRodinFile rodinFile = RodinCore.valueOf((IFile) element);
+					if (rodinFile != null)
+						root = (IEventBRoot) rodinFile.getRoot();
+				}
+			}
+		}
+		return root;
+	}
+
+	private IFile extractResource(final IEventBRoot rootElement) {
+		IFile resource = null;
+		if (rootElement == null) {
+			resource = null;
+		} else if (rootElement instanceof IMachineRoot) {
+			resource = ((IMachineRoot) rootElement).getSCMachineRoot()
+					.getResource();
+		} else if (rootElement instanceof IContextRoot) {
+			resource = ((IContextRoot) rootElement).getSCContextRoot()
+					.getResource();
+		}
+		return resource;
+	}
+
+	private void registerModificationListener(final IFile resource) {
+		if (listener != null) {
+			ResourcesPlugin.getWorkspace().removeResourceChangeListener(
+					listener);
+		}
+		listener = new ModificationListener(resource);
+		ResourcesPlugin.getWorkspace().addResourceChangeListener(listener);
+	}
+
+	public void selectionChanged(final IAction action,
+			final ISelection selection) {
+		fSelection = selection;
+	}
+
+}

de.prob2.units.feature/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>de.prob2.units.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>

de.prob2.units.feature/.settings/org.eclipse.core.resources.prefs

+#Tue Nov 29 16:17:25 CET 2011
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

de.prob2.units.feature/.settings/org.eclipse.core.runtime.prefs

+#Tue Nov 29 16:17:25 CET 2011
+eclipse.preferences.version=1
+line.separator=\n

de.prob2.units.feature/build.properties

+bin.includes = feature.xml

de.prob2.units.feature/feature.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="de.prob2.units.feature"
+      label="ProB for Rodin2 - Physical Units Support"
+      version="2.3.5.qualifier"
+      provider-name="HHU Düsseldorf STUPS Group">
+
+   <description url="http://www.stups.uni-duesseldorf.de/ProB">
+      ProB is an animator and model checker for the B-Method. It allows fully automatic animation of many B specifications, and can be used to systematically check a specification for errors. 
+Part of the research and development was conducted within the EPSRC funded projects ABCD and iMoc, and within the EU funded project Rodin. 
+Development is continued under the EU funded project Deploy and the DFG project Gepavas. 
+ProB has been successfully used on various industrial specifications and is now being used within Siemens.
+   </description>
+
+   <copyright>
+      (C) 2000-2011 Michael Leuschel (and many others) All rights reserved.
+   </copyright>
+
+   <license url="http://www.eclipse.org/org/documents/epl-v10.html">
+      ProB can be used freely for commercial, non-commercial and academic
+use under the Eclipse Public Licence v. 1.0. (below) 
+For availability of commercial support, please contact the author
+(http://www.stups.uni-duesseldorf.de/~leuschel). 
+Use of ProB&apos;s nauty library for symmetry reduction implies further
+restrictions (no applications with nontrivial military significance,
+see http://cs.anu.edu.au/~bdm/nauty/).
+--- 
+Eclipse Public License - v. 1.0
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS
+ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT&apos;S ACCEPTANCE
+OF THIS AGREEMENT.
+1. DEFINITIONS
+&quot;Contribution&quot; means:
+a) in the case of the initial Contributor, the initial code and
+documentation distributed under this Agreement, and
+b) in the case of each subsequent Contributor:
+i) changes to the Program, and
+ii) additions to the Program;
+where such changes and/or additions to the Program originate
+from and are distributed by that particular Contributor. A Contribution
+&apos;originates&apos; from a Contributor if it was added to the Program
+by such Contributor itself or anyone acting on such Contributor&apos;s
+behalf. Contributions do not include additions to the Program
+which: (i) are separate modules of software distributed in conjunction
+with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.
+&quot;Contributor&quot; means any person or entity that distributes the
+Program.
+&quot;Licensed Patents&quot; mean patent claims licensable by a Contributor
+which are necessarily infringed by the use or sale of its Contribution
+alone or when combined with the Program.
+&quot;Program&quot; means the Contributions distributed in accordance with
+this Agreement.
+&quot;Recipient&quot; means anyone who receives the Program under this
+Agreement, including all Contributors.
+2. GRANT OF RIGHTS
+a) Subject to the terms of this Agreement, each Contributor hereby
+grants Recipient a non-exclusive, worldwide, royalty-free copyright
+license to reproduce, prepare derivative works of, publicly display,
+publicly perform, distribute and sublicense the Contribution
+of such Contributor, if any, and such derivative works, in source
+code and object code form.
+b) Subject to the terms of this Agreement, each Contributor hereby
+grants Recipient a non-exclusive, worldwide, royalty-free patent
+license under Licensed Patents to make, use, sell, offer to sell,
+import and otherwise transfer the Contribution of such Contributor,
+if any, in source code and object code form. This patent license
+shall apply to the combination of the Contribution and the Program
+if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to
+be covered by the Licensed Patents. The patent license shall
+not apply to any other combinations which include the Contribution.
+No hardware per se is licensed hereunder.
+c) Recipient understands that although each Contributor grants
+the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe
+the patent or other intellectual property rights of any other
+entity. Each Contributor disclaims any liability to Recipient
+for claims brought by any other entity based on infringement
+of intellectual property rights or otherwise. As a condition
+to exercising the rights and licenses granted hereunder, each
+Recipient hereby assumes sole responsibility to secure any other
+intellectual property rights needed, if any. For example, if
+a third party patent license is required to allow Recipient to
+distribute the Program, it is Recipient&apos;s responsibility to acquire
+that license before distributing the Program.
+d) Each Contributor represents that to its knowledge it has sufficient
+copyright rights in its Contribution, if any, to grant the copyright
+license set forth in this Agreement.
+3. REQUIREMENTS
+A Contributor may choose to distribute the Program in object
+code form under its own license agreement, provided that:
+a) it complies with the terms and conditions of this Agreement;
+and
+b) its license agreement:
+i) effectively disclaims on behalf of all Contributors all warranties
+and conditions, express and implied, including warranties or
+conditions of title and non-infringement, and implied warranties
+or conditions of merchantability and fitness for a particular
+purpose;
+ii) effectively excludes on behalf of all Contributors all liability
+for damages, including direct, indirect, special, incidental
+and consequential damages, such as lost profits;
+iii) states that any provisions which differ from this Agreement
+are offered by that Contributor alone and not by any other party;
+and
+iv) states that source code for the Program is available from
+such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for
+software exchange.
+When the Program is made available in source code form:
+a) it must be made available under this Agreement; and
+b) a copy of this Agreement must be included with each copy of
+the Program.
+Contributors may not remove or alter any copyright notices contained
+within the Program.
+Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.
+4. COMMERCIAL DISTRIBUTION
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While
+this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+(&quot;Commercial Contributor&quot;) hereby agrees to defend and indemnify
+every other Contributor (&quot;Indemnified Contributor&quot;) against any
+losses, damages and costs (collectively &quot;Losses&quot;) arising from
+claims, lawsuits and other legal actions brought by a third party
+against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection
+with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any
+claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor
+must: a) promptly notify the Commercial Contributor in writing
+of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense
+and any related settlement negotiations. The Indemnified Contributor
+may participate in any such claim at its own expense.
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor&apos;s responsibility
+alone. Under this section, the Commercial Contributor would have
+to defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any
+other Contributor to pay any damages as a result, the Commercial
+Contributor must pay those damages.
+5. NO WARRANTY
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM
+IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with
+its exercise of rights under this Agreement , including but not
+limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or
+equipment, and unavailability or interruption of operations.
+6. DISCLAIMER OF LIABILITY
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE
+OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGES.
+7. GENERAL
+If any provision of this Agreement is invalid or unenforceable
+under applicable law, it shall not affect the validity or enforceability
+of the remainder of the terms of this Agreement, and without
+further action by the parties hereto, such provision shall be
+reformed to the minimum extent necessary to make such provision
+valid and enforceable.
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging
+that the Program itself (excluding combinations of the Program
+with other software or hardware) infringes such Recipient&apos;s patent(s),
+then such Recipient&apos;s rights granted under Section 2(b) shall
+terminate as of the date such litigation is filed.
+All Recipient&apos;s rights under this Agreement shall terminate if
+it fails to comply with any of the material terms or conditions
+of this Agreement and does not cure such failure in a reasonable
+period of time after becoming aware of such noncompliance. If
+all Recipient&apos;s rights under this Agreement terminate, Recipient
+agrees to cease use and distribution of the Program as soon as
+reasonably practicable. However, Recipient&apos;s obligations under
+this Agreement and any licenses granted by Recipient relating
+to the Program shall continue and survive.
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted
+and may only be modified in the following manner. The Agreement
+Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other
+than the Agreement Steward has the right to modify this Agreement.
+The Eclipse Foundation is the initial Agreement Steward. The
+Eclipse Foundation may assign the responsibility to serve as
+the Agreement Steward to a suitable separate entity. Each new
+version of the Agreement will be given a distinguishing version
+number. The Program (including Contributions) may always be distributed
+subject to the version of the Agreement under which it was received.
+In addition, after a new version of the Agreement is published,
+Contributor may elect to distribute the Program (including its
+Contributions) under the new version. Except as expressly stated
+in Sections 2(a) and 2(b) above, Recipient receives no rights
+or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under
+this Agreement are reserved.
+This Agreement is governed by the laws of the State of New York
+and the intellectual property laws of the United States of America.
+No party to this Agreement will bring a legal action under this
+Agreement more than one year after the cause of action arose.
+Each party waives its rights to a jury trial in any resulting
+litigation.
+   </license>
+
+   <requires>
+      <import feature="de.prob2.feature" version="2.3.5" match="greaterOrEqual"/>
+   </requires>
+
+   <plugin
+         id="de.prob.units"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>

settings.gradle

 
-include 'de.prob.core', 'de.bmotionstudio.gef.editor' ,'de.bmotionstudio.rodin', 'de.bmotionstudio.help' , 'de.prob.plugin', 'de.prob.ui', 'de.prob2.feature'
+include 'de.prob.core', 'de.prob.core.tests', 'de.bmotionstudio.gef.editor' ,'de.bmotionstudio.rodin', 'de.bmotionstudio.help' , 'de.prob.plugin', 'de.prob.ui', 'de.prob2.feature', 'de.prob.units', 'de.prob2.units.feature'