diff --git a/de.bmotionstudio.gef.editor/.project b/de.bmotionstudio.gef.editor/.project index 5b47a81f892de4a2a747c3084f04e161bff4cb17..266629c4895e933adf14f11029b247fd87cb776e 100644 --- a/de.bmotionstudio.gef.editor/.project +++ b/de.bmotionstudio.gef.editor/.project @@ -1,28 +1,28 @@ -<?xml version="1.0" encoding="UTF-8"?> -<projectDescription> - <name>de.bmotionstudio.gef.editor</name> - <comment></comment> - <projects> - </projects> - <buildSpec> - <buildCommand> - <name>org.eclipse.jdt.core.javabuilder</name> - <arguments> - </arguments> - </buildCommand> - <buildCommand> - <name>org.eclipse.pde.ManifestBuilder</name> - <arguments> - </arguments> - </buildCommand> - <buildCommand> - <name>org.eclipse.pde.SchemaBuilder</name> - <arguments> - </arguments> - </buildCommand> - </buildSpec> - <natures> - <nature>org.eclipse.pde.PluginNature</nature> - <nature>org.eclipse.jdt.core.javanature</nature> - </natures> -</projectDescription> +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>de.bmotionstudio.gef.editor</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.jdt.core.javabuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.pde.ManifestBuilder</name> + <arguments> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.pde.SchemaBuilder</name> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.pde.PluginNature</nature> + <nature>org.eclipse.jdt.core.javanature</nature> + </natures> +</projectDescription> diff --git a/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.resources.prefs b/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.resources.prefs index bb7d9ec6f5c0705e126c1655f0ac4bd64e5cc4e6..35c1f5a73d13cf6b4f0a370335f908432f2fe713 100644 --- a/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.resources.prefs +++ b/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.resources.prefs @@ -1,3 +1,3 @@ -#Tue Nov 29 16:16:11 CET 2011 -eclipse.preferences.version=1 -encoding/<project>=UTF-8 +#Tue Nov 29 16:16:11 CET 2011 +eclipse.preferences.version=1 +encoding/<project>=UTF-8 diff --git a/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.runtime.prefs b/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.runtime.prefs index 98fd8a4c46ac8acfc4de4fba2caac68703d8b58d..11c1f686b491df30d3f56ce88d8512986f4f43b2 100644 --- a/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.runtime.prefs +++ b/de.bmotionstudio.gef.editor/.settings/org.eclipse.core.runtime.prefs @@ -1,3 +1,3 @@ -#Tue Nov 29 16:16:11 CET 2011 -eclipse.preferences.version=1 -line.separator=\n +#Tue Nov 29 16:16:11 CET 2011 +eclipse.preferences.version=1 +line.separator=\n diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AppContextMenuProvider.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AppContextMenuProvider.java index 1cb2efb1c6e01ee3050551cd3871c79a051cc93b..68d5c225496232e58686bf258dc583d44f00198a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AppContextMenuProvider.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AppContextMenuProvider.java @@ -1,311 +1,311 @@ -/** - * (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.bmotionstudio.gef.editor; - -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.Platform; -import org.eclipse.gef.ContextMenuProvider; -import org.eclipse.gef.EditPartViewer; -import org.eclipse.gef.ui.actions.ActionRegistry; -import org.eclipse.gef.ui.actions.GEFActionConstants; -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.action.IMenuManager; -import org.eclipse.jface.action.MenuManager; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.ui.actions.ActionFactory; - -import de.bmotionstudio.gef.editor.action.SchedulerEventAction; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; -import de.bmotionstudio.gef.editor.part.VisualizationPart; -import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; - -public class AppContextMenuProvider extends ContextMenuProvider { - - private ActionRegistry actionRegistry; - - private IExtensionRegistry registry = Platform.getExtensionRegistry(); - - private String[] eventIDs = { AttributeConstants.EVENT_MOUSECLICK }; - - public AppContextMenuProvider(EditPartViewer viewer, ActionRegistry registry) { - super(viewer); - setActionRegistry(registry); - } - - @Override - public void buildContextMenu(IMenuManager menu) { - - IAction action; - - GEFActionConstants.addStandardActionGroups(menu); - - action = getActionRegistry().getAction(ActionFactory.UNDO.getId()); - menu.appendToGroup(GEFActionConstants.GROUP_UNDO, action); - - action = getActionRegistry().getAction(ActionFactory.REDO.getId()); - menu.appendToGroup(GEFActionConstants.GROUP_UNDO, action); - - action = actionRegistry.getAction(ActionFactory.COPY.getId()); - menu.appendToGroup(GEFActionConstants.GROUP_COPY, action); - - action = actionRegistry.getAction(ActionFactory.PASTE.getId()); - menu.appendToGroup(GEFActionConstants.GROUP_COPY, action); - - action = getActionRegistry().getAction(ActionFactory.DELETE.getId()); - menu.appendToGroup(GEFActionConstants.GROUP_EDIT, action); - - buildCustomMenu(menu); - - buildObserverMenu(menu); - - buildEventMenu(menu); - - } - - private void buildCustomMenu(IMenuManager menu) { - - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.installMenu"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("menu".equals(configurationElement.getName())) { - - try { - - IInstallMenu installMenuClass = (IInstallMenu) configurationElement - .createExecutableExtension("class"); - - installMenuClass.installMenu(menu, getActionRegistry()); - - } catch (final CoreException e) { - e.printStackTrace(); - } - - } - - } - - } - - } - - private void buildObserverMenu(IMenuManager menu) { - - final MenuManager handleObserverMenu = new MenuManager("Observers", - BMotionStudioImage.getImageDescriptor( - BMotionEditorPlugin.PLUGIN_ID, - "icons/icon_observer.gif"), "observerMenu"); - menu.appendToGroup(GEFActionConstants.GROUP_ADD, handleObserverMenu); - - IStructuredSelection selection = (IStructuredSelection) BMotionEditorPlugin - .getActiveEditor().getEditorSite().getSelectionProvider() - .getSelection(); - - if (selection.getFirstElement() instanceof AppAbstractEditPart) { - - BControl bcontrol = (BControl) ((AppAbstractEditPart) selection - .getFirstElement()).getModel(); - - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.observer"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("observer".equals(configurationElement.getName())) { - - final String observerClassName = configurationElement - .getAttribute("class"); - final String observerName = configurationElement - .getAttribute("name"); - - if (checkIncludeObserver(observerClassName, bcontrol)) { - - IAction action = getActionRegistry().getAction( - "de.bmotionstudio.gef.editor.observerAction." - + observerClassName); - action.setText(observerName); - action.setToolTipText(observerName); - - if (bcontrol.hasObserver(observerClassName)) { - action.setImageDescriptor(BMotionStudioImage - .getImageDescriptor( - BMotionEditorPlugin.PLUGIN_ID, - "icons/icon_chop.gif")); - } else { - action.setImageDescriptor(null); - } - handleObserverMenu.add(action); - - } - - } - - } - - } - - } - - } - - private boolean checkIncludeObserver(String observerID, BControl control) { - - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.includeObserver"); - - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("include".equals(configurationElement.getName())) { - - String langID = configurationElement - .getAttribute("language"); - - if (langID.equals(control.getVisualization().getLanguage())) { - - for (IConfigurationElement cObserver : configurationElement - .getChildren("observer")) { - - String oID = cObserver.getAttribute("id"); - - if (observerID.equals(oID)) { - - for (IConfigurationElement configBControl : cObserver - .getChildren("control")) { - - String bID = configBControl - .getAttribute("id"); - - if (control.getType().equals(bID)) { - return true; - } - - } - - } - - } - - } - - } - - } - } - - return false; - - } - - private void buildEventMenu(IMenuManager menu) { - - MenuManager handleEventMenu = new MenuManager("Events", - BMotionStudioImage.getImageDescriptor( - BMotionEditorPlugin.PLUGIN_ID, "icons/icon_event.png"), - "eventMenu"); - menu.appendToGroup(GEFActionConstants.GROUP_ADD, handleEventMenu); - - IStructuredSelection selection = (IStructuredSelection) BMotionEditorPlugin - .getActiveEditor().getEditorSite().getSelectionProvider() - .getSelection(); - - if ((selection.getFirstElement() instanceof AppAbstractEditPart) - && !(selection.getFirstElement() instanceof VisualizationPart)) { - - BControl bcontrol = (BControl) ((AppAbstractEditPart) selection - .getFirstElement()).getModel(); - - // Has event - if (bcontrol.hasEvent(eventIDs[0])) { - - SchedulerEvent event = bcontrol.getEvent(eventIDs[0]); - - SchedulerEventAction action = (SchedulerEventAction) getActionRegistry() - .getAction( - "de.bmotionstudio.gef.editor.SchedulerEventAction." - + event.getID()); - action.setEventID(eventIDs[0]); - action.setText(event.getName()); - action.setImageDescriptor(BMotionStudioImage - .getImageDescriptor(BMotionEditorPlugin.PLUGIN_ID, - "icons/icon_chop.gif")); - handleEventMenu.add(action); - - } else { // Has no event - - IExtensionPoint schedulerExtensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.schedulerEvent"); - for (IExtension schedulerExtension : schedulerExtensionPoint - .getExtensions()) { - for (IConfigurationElement configSchedulerElement : schedulerExtension - .getConfigurationElements()) { - - if ("schedulerEvent".equals(configSchedulerElement - .getName())) { - - String sClassName = configSchedulerElement - .getAttribute("class"); - Boolean show = Boolean - .valueOf(configSchedulerElement - .getAttribute("menu")); - - if (show) { - - SchedulerEventAction action = (SchedulerEventAction) getActionRegistry() - .getAction( - "de.bmotionstudio.gef.editor.SchedulerEventAction." - + sClassName); - action.setEventID(eventIDs[0]); - action.setText(configSchedulerElement - .getAttribute("name")); - - // if (bcontrol.hasEvent(eventIDs[0])) { - // action - // .setImageDescriptor(BMotionStudioImage - // .getImageDescriptor( - // BMotionEditorPlugin.PLUGIN_ID, - // "icons/icon_chop.gif")); - // } else { - - action.setImageDescriptor(null); - - // } - - handleEventMenu.add(action); - - } - - } - - } - - } - - } - - } - - } - - private ActionRegistry getActionRegistry() { - return actionRegistry; - } - - private void setActionRegistry(ActionRegistry registry) { - actionRegistry = registry; - } - +/** + * (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.bmotionstudio.gef.editor; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.Platform; +import org.eclipse.gef.ContextMenuProvider; +import org.eclipse.gef.EditPartViewer; +import org.eclipse.gef.ui.actions.ActionRegistry; +import org.eclipse.gef.ui.actions.GEFActionConstants; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.ui.actions.ActionFactory; + +import de.bmotionstudio.gef.editor.action.OpenSchedulerEventAction; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; +import de.bmotionstudio.gef.editor.part.VisualizationPart; +import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; + +public class AppContextMenuProvider extends ContextMenuProvider { + + private ActionRegistry actionRegistry; + + private IExtensionRegistry registry = Platform.getExtensionRegistry(); + + private String[] eventIDs = { AttributeConstants.EVENT_MOUSECLICK }; + + public AppContextMenuProvider(EditPartViewer viewer, ActionRegistry registry) { + super(viewer); + setActionRegistry(registry); + } + + @Override + public void buildContextMenu(IMenuManager menu) { + + IAction action; + + GEFActionConstants.addStandardActionGroups(menu); + + action = getActionRegistry().getAction(ActionFactory.UNDO.getId()); + menu.appendToGroup(GEFActionConstants.GROUP_UNDO, action); + + action = getActionRegistry().getAction(ActionFactory.REDO.getId()); + menu.appendToGroup(GEFActionConstants.GROUP_UNDO, action); + + action = actionRegistry.getAction(ActionFactory.COPY.getId()); + menu.appendToGroup(GEFActionConstants.GROUP_COPY, action); + + action = actionRegistry.getAction(ActionFactory.PASTE.getId()); + menu.appendToGroup(GEFActionConstants.GROUP_COPY, action); + + action = getActionRegistry().getAction(ActionFactory.DELETE.getId()); + menu.appendToGroup(GEFActionConstants.GROUP_EDIT, action); + + buildCustomMenu(menu); + + buildObserverMenu(menu); + + buildEventMenu(menu); + + } + + private void buildCustomMenu(IMenuManager menu) { + + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.installMenu"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("menu".equals(configurationElement.getName())) { + + try { + + IInstallMenu installMenuClass = (IInstallMenu) configurationElement + .createExecutableExtension("class"); + + installMenuClass.installMenu(menu, getActionRegistry()); + + } catch (final CoreException e) { + e.printStackTrace(); + } + + } + + } + + } + + } + + private void buildObserverMenu(IMenuManager menu) { + + final MenuManager handleObserverMenu = new MenuManager("Observers", + BMotionStudioImage.getImageDescriptor( + BMotionEditorPlugin.PLUGIN_ID, + "icons/icon_observer.gif"), "observerMenu"); + menu.appendToGroup(GEFActionConstants.GROUP_ADD, handleObserverMenu); + + IStructuredSelection selection = (IStructuredSelection) BMotionEditorPlugin + .getActiveEditor().getEditorSite().getSelectionProvider() + .getSelection(); + + if (selection.getFirstElement() instanceof AppAbstractEditPart) { + + BControl bcontrol = (BControl) ((AppAbstractEditPart) selection + .getFirstElement()).getModel(); + + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.observer"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("observer".equals(configurationElement.getName())) { + + final String observerClassName = configurationElement + .getAttribute("class"); + final String observerName = configurationElement + .getAttribute("name"); + + if (checkIncludeObserver(observerClassName, bcontrol)) { + + IAction action = getActionRegistry().getAction( + "de.bmotionstudio.gef.editor.observerAction." + + observerClassName); + action.setText(observerName); + action.setToolTipText(observerName); + + if (bcontrol.hasObserver(observerClassName)) { + action.setImageDescriptor(BMotionStudioImage + .getImageDescriptor( + BMotionEditorPlugin.PLUGIN_ID, + "icons/icon_chop.gif")); + } else { + action.setImageDescriptor(null); + } + handleObserverMenu.add(action); + + } + + } + + } + + } + + } + + } + + private boolean checkIncludeObserver(String observerID, BControl control) { + + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.includeObserver"); + + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("include".equals(configurationElement.getName())) { + + String langID = configurationElement + .getAttribute("language"); + + if (langID.equals(control.getVisualization().getLanguage())) { + + for (IConfigurationElement cObserver : configurationElement + .getChildren("observer")) { + + String oID = cObserver.getAttribute("id"); + + if (observerID.equals(oID)) { + + for (IConfigurationElement configBControl : cObserver + .getChildren("control")) { + + String bID = configBControl + .getAttribute("id"); + + if (control.getType().equals(bID)) { + return true; + } + + } + + } + + } + + } + + } + + } + } + + return false; + + } + + private void buildEventMenu(IMenuManager menu) { + + MenuManager handleEventMenu = new MenuManager("Events", + BMotionStudioImage.getImageDescriptor( + BMotionEditorPlugin.PLUGIN_ID, "icons/icon_event.png"), + "eventMenu"); + menu.appendToGroup(GEFActionConstants.GROUP_ADD, handleEventMenu); + + IStructuredSelection selection = (IStructuredSelection) BMotionEditorPlugin + .getActiveEditor().getEditorSite().getSelectionProvider() + .getSelection(); + + if ((selection.getFirstElement() instanceof AppAbstractEditPart) + && !(selection.getFirstElement() instanceof VisualizationPart)) { + + BControl bcontrol = (BControl) ((AppAbstractEditPart) selection + .getFirstElement()).getModel(); + + // Has event + if (bcontrol.hasEvent(eventIDs[0])) { + + SchedulerEvent event = bcontrol.getEvent(eventIDs[0]); + + OpenSchedulerEventAction action = (OpenSchedulerEventAction) getActionRegistry() + .getAction( + "de.bmotionstudio.gef.editor.SchedulerEventAction." + + event.getID()); + action.setEventID(eventIDs[0]); + action.setText(event.getName()); + action.setImageDescriptor(BMotionStudioImage + .getImageDescriptor(BMotionEditorPlugin.PLUGIN_ID, + "icons/icon_chop.gif")); + handleEventMenu.add(action); + + } else { // Has no event + + IExtensionPoint schedulerExtensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.schedulerEvent"); + for (IExtension schedulerExtension : schedulerExtensionPoint + .getExtensions()) { + for (IConfigurationElement configSchedulerElement : schedulerExtension + .getConfigurationElements()) { + + if ("schedulerEvent".equals(configSchedulerElement + .getName())) { + + String sClassName = configSchedulerElement + .getAttribute("class"); + Boolean show = Boolean + .valueOf(configSchedulerElement + .getAttribute("menu")); + + if (show) { + + OpenSchedulerEventAction action = (OpenSchedulerEventAction) getActionRegistry() + .getAction( + "de.bmotionstudio.gef.editor.SchedulerEventAction." + + sClassName); + action.setEventID(eventIDs[0]); + action.setText(configSchedulerElement + .getAttribute("name")); + + // if (bcontrol.hasEvent(eventIDs[0])) { + // action + // .setImageDescriptor(BMotionStudioImage + // .getImageDescriptor( + // BMotionEditorPlugin.PLUGIN_ID, + // "icons/icon_chop.gif")); + // } else { + + action.setImageDescriptor(null); + + // } + + handleEventMenu.add(action); + + } + + } + + } + + } + + } + + } + + } + + private ActionRegistry getActionRegistry() { + return actionRegistry; + } + + private void setActionRegistry(ActionRegistry registry) { + actionRegistry = registry; + } + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AttributeConstants.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AttributeConstants.java index 5fb0bfdd4b5195d6a1f2c6666ced65362a3911e3..49a11fee08c328bdb9a5cadb6191836330c19772 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AttributeConstants.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/AttributeConstants.java @@ -1,60 +1,60 @@ -/** - * (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.bmotionstudio.gef.editor; - -public final class AttributeConstants { - - public static final String ATTRIBUTE_X = "de.bmotionstudio.gef.editor.attribute.BAttributeX"; - public static final String ATTRIBUTE_Y = "de.bmotionstudio.gef.editor.attribute.BAttributeY"; - public static final String ATTRIBUTE_WIDTH = "de.bmotionstudio.gef.editor.attribute.BAttributeWidth"; - public static final String ATTRIBUTE_HEIGHT = "de.bmotionstudio.gef.editor.attribute.BAttributeHeight"; - public static final String ATTRIBUTE_CUSTOM = "de.bmotionstudio.gef.editor.attribute.BAttributeCustom"; - public static final String ATTRIBUTE_ID = "de.bmotionstudio.gef.editor.attribute.BAttributeID"; - public static final String ATTRIBUTE_VISIBLE = "de.bmotionstudio.gef.editor.attribute.BAttributeVisible"; - - public static final String ATTRIBUTE_BACKGROUND_IMAGE = "de.bmotionstudio.gef.editor.attribute.BAttributeImage"; - public static final String ATTRIBUTE_BACKGROUND_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeBackgroundColor"; - public static final String ATTRIBUTE_FOREGROUND_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeForegroundColor"; - public static final String ATTRIBUTE_BACKGROUND_VISIBLE = "de.bmotionstudio.gef.editor.attribute.BAttributeBackgroundVisible"; - public static final String ATTRIBUTE_IMAGE = "de.bmotionstudio.gef.editor.attribute.BAttributeImage"; - public static final String ATTRIBUTE_TEXT = "de.bmotionstudio.gef.editor.attribute.BAttributeText"; - public static final String ATTRIBUTE_TEXT_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeTextColor"; - public static final String ATTRIBUTE_FILL_HEIGHT = "de.bmotionstudio.gef.editor.attribute.BAttributeFillHeight"; - public static final String ATTRIBUTE_FILL_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeFillColor"; - public static final String ATTRIBUTE_SHOWS_MEASURE = "de.bmotionstudio.gef.editor.attribute.BAttributeShowMeasure"; - public static final String ATTRIBUTE_MEASURE_MAXPOS = "de.bmotionstudio.gef.editor.attribute.BAttributeMeasureMaxPos"; - public static final String ATTRIBUTE_MEASURE_INTERVAL = "de.bmotionstudio.gef.editor.attribute.BAttributeMeasureInterval"; - public static final String ATTRIBUTE_ALPHA = "de.bmotionstudio.gef.editor.attribute.BAttributeAlpha"; - public static final String ATTRIBUTE_OUTLINEALPHA = "de.bmotionstudio.gef.editor.attribute.BAttributeOutlineAlpha"; - public static final String ATTRIBUTE_FONT = "de.bmotionstudio.gef.editor.attribute.BAttributeFont"; - public static final String ATTRIBUTE_ENABLED = "de.bmotionstudio.gef.editor.attribute.BAttributeEnabled"; - public static final String ATTRIBUTE_CHECKED = "de.bmotionstudio.gef.editor.attribute.BAttributeChecked"; - public static final String ATTRIBUTE_VALUE = "de.bmotionstudio.gef.editor.attribute.BAttributeValue"; - public static final String ATTRIBUTE_BUTTONGROUP = "de.bmotionstudio.gef.editor.attribute.BAttributeButtonGroup"; - public static final String ATTRIBUTE_SHAPE = "de.bmotionstudio.gef.editor.attribute.BAttributeShape"; - public static final String ATTRIBUTE_ORIENTATION = "de.bmotionstudio.gef.editor.attribute.BAttributeOrientation"; - public static final String ATTRIBUTE_DIRECTION = "de.bmotionstudio.gef.editor.attribute.BAttributeDirection"; - public static final String ATTRIBUTE_FILLTYPE = "de.bmotionstudio.gef.editor.attribute.BAttributeFillType"; - public static final String ATTRIBUTE_LINEWIDTH = "de.bmotionstudio.gef.editor.attribute.BAttributeLineWidth"; - public static final String ATTRIBUTE_LINESTYLE = "de.bmotionstudio.gef.editor.attribute.BAttributeLineStyle"; - public static final String ATTRIBUTE_TRUEVALUE = "de.bmotionstudio.gef.editor.attribute.BAttributeTrueValue"; - public static final String ATTRIBUTE_FALSEVALUE = "de.bmotionstudio.gef.editor.attribute.BAttributeFalseValue"; - public static final String ATTRIBUTE_LABEL = "de.bmotionstudio.gef.editor.attribute.BAttributeLabel"; - public static final String ATTRIBUTE_OFFSET_H = "de.bmotionstudio.gef.editor.attribute.BAttributeOffsetH"; - public static final String ATTRIBUTE_OFFSET_V = "de.bmotionstudio.gef.editor.attribute.BAttributeOffsetV"; - public static final String ATTRIBUTE_CONNECTION_SOURCE_DECORATION = "de.bmotionstudio.gef.editor.attribute.BAttributeConnectionSourceDecoration"; - public static final String ATTRIBUTE_CONNECTION_TARGET_DECORATION = "de.bmotionstudio.gef.editor.attribute.BAttributeConnectionTargetDecoration"; - - public static final String ATTRIBUTE_SIZE = "de.bmotionstudio.gef.editor.attribute.BAttributeSize"; - public static final String ATTRIBUTE_COORDINATES = "de.bmotionstudio.gef.editor.attribute.BAttributeCoordinates"; - public static final String ATTRIBUTE_MISC = "de.bmotionstudio.gef.editor.attribute.BAttributeMisc"; - public static final String ATTRIBUTE_MAIN = "de.bmotionstudio.gef.editor.attribute.BAttributeMain"; - - public static final String EVENT_MOUSECLICK = "de.bmotionstudio.gef.editor.event.OnClickEvent"; - public static final String EVENT_MOUSEDBLCLICK = "de.bmotionstudio.gef.editor.event.OnDblClickEvent"; - +/** + * (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.bmotionstudio.gef.editor; + +public final class AttributeConstants { + + public static final String ATTRIBUTE_X = "de.bmotionstudio.gef.editor.attribute.BAttributeX"; + public static final String ATTRIBUTE_Y = "de.bmotionstudio.gef.editor.attribute.BAttributeY"; + public static final String ATTRIBUTE_WIDTH = "de.bmotionstudio.gef.editor.attribute.BAttributeWidth"; + public static final String ATTRIBUTE_HEIGHT = "de.bmotionstudio.gef.editor.attribute.BAttributeHeight"; + public static final String ATTRIBUTE_CUSTOM = "de.bmotionstudio.gef.editor.attribute.BAttributeCustom"; + public static final String ATTRIBUTE_ID = "de.bmotionstudio.gef.editor.attribute.BAttributeID"; + public static final String ATTRIBUTE_VISIBLE = "de.bmotionstudio.gef.editor.attribute.BAttributeVisible"; + + public static final String ATTRIBUTE_BACKGROUND_IMAGE = "de.bmotionstudio.gef.editor.attribute.BAttributeImage"; + public static final String ATTRIBUTE_BACKGROUND_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeBackgroundColor"; + public static final String ATTRIBUTE_FOREGROUND_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeForegroundColor"; + public static final String ATTRIBUTE_BACKGROUND_VISIBLE = "de.bmotionstudio.gef.editor.attribute.BAttributeBackgroundVisible"; + public static final String ATTRIBUTE_IMAGE = "de.bmotionstudio.gef.editor.attribute.BAttributeImage"; + public static final String ATTRIBUTE_TEXT = "de.bmotionstudio.gef.editor.attribute.BAttributeText"; + public static final String ATTRIBUTE_TEXT_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeTextColor"; + public static final String ATTRIBUTE_FILL_HEIGHT = "de.bmotionstudio.gef.editor.attribute.BAttributeFillHeight"; + public static final String ATTRIBUTE_FILL_COLOR = "de.bmotionstudio.gef.editor.attribute.BAttributeFillColor"; + public static final String ATTRIBUTE_SHOWS_MEASURE = "de.bmotionstudio.gef.editor.attribute.BAttributeShowMeasure"; + public static final String ATTRIBUTE_MEASURE_MAXPOS = "de.bmotionstudio.gef.editor.attribute.BAttributeMeasureMaxPos"; + public static final String ATTRIBUTE_MEASURE_INTERVAL = "de.bmotionstudio.gef.editor.attribute.BAttributeMeasureInterval"; + public static final String ATTRIBUTE_ALPHA = "de.bmotionstudio.gef.editor.attribute.BAttributeAlpha"; + public static final String ATTRIBUTE_OUTLINEALPHA = "de.bmotionstudio.gef.editor.attribute.BAttributeOutlineAlpha"; + public static final String ATTRIBUTE_FONT = "de.bmotionstudio.gef.editor.attribute.BAttributeFont"; + public static final String ATTRIBUTE_ENABLED = "de.bmotionstudio.gef.editor.attribute.BAttributeEnabled"; + public static final String ATTRIBUTE_CHECKED = "de.bmotionstudio.gef.editor.attribute.BAttributeChecked"; + public static final String ATTRIBUTE_VALUE = "de.bmotionstudio.gef.editor.attribute.BAttributeValue"; + public static final String ATTRIBUTE_BUTTONGROUP = "de.bmotionstudio.gef.editor.attribute.BAttributeButtonGroup"; + public static final String ATTRIBUTE_SHAPE = "de.bmotionstudio.gef.editor.attribute.BAttributeShape"; + public static final String ATTRIBUTE_ORIENTATION = "de.bmotionstudio.gef.editor.attribute.BAttributeOrientation"; + public static final String ATTRIBUTE_DIRECTION = "de.bmotionstudio.gef.editor.attribute.BAttributeDirection"; + public static final String ATTRIBUTE_FILLTYPE = "de.bmotionstudio.gef.editor.attribute.BAttributeFillType"; + public static final String ATTRIBUTE_LINEWIDTH = "de.bmotionstudio.gef.editor.attribute.BAttributeLineWidth"; + public static final String ATTRIBUTE_LINESTYLE = "de.bmotionstudio.gef.editor.attribute.BAttributeLineStyle"; + public static final String ATTRIBUTE_TRUEVALUE = "de.bmotionstudio.gef.editor.attribute.BAttributeTrueValue"; + public static final String ATTRIBUTE_FALSEVALUE = "de.bmotionstudio.gef.editor.attribute.BAttributeFalseValue"; + public static final String ATTRIBUTE_LABEL = "de.bmotionstudio.gef.editor.attribute.BAttributeLabel"; + public static final String ATTRIBUTE_OFFSET_H = "de.bmotionstudio.gef.editor.attribute.BAttributeOffsetH"; + public static final String ATTRIBUTE_OFFSET_V = "de.bmotionstudio.gef.editor.attribute.BAttributeOffsetV"; + public static final String ATTRIBUTE_CONNECTION_SOURCE_DECORATION = "de.bmotionstudio.gef.editor.attribute.BAttributeConnectionSourceDecoration"; + public static final String ATTRIBUTE_CONNECTION_TARGET_DECORATION = "de.bmotionstudio.gef.editor.attribute.BAttributeConnectionTargetDecoration"; + + public static final String ATTRIBUTE_SIZE = "de.bmotionstudio.gef.editor.attribute.BAttributeSize"; + public static final String ATTRIBUTE_COORDINATES = "de.bmotionstudio.gef.editor.attribute.BAttributeCoordinates"; + public static final String ATTRIBUTE_MISC = "de.bmotionstudio.gef.editor.attribute.BAttributeMisc"; + public static final String ATTRIBUTE_MAIN = "de.bmotionstudio.gef.editor.attribute.BAttributeMain"; + + public static final String EVENT_MOUSECLICK = "de.bmotionstudio.gef.editor.event.OnClickEvent"; + public static final String EVENT_MOUSEDBLCLICK = "de.bmotionstudio.gef.editor.event.OnDblClickEvent"; + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BControlCreationFactory.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BControlCreationFactory.java index f94182dcb703ac07236ce66209167035b84edd4c..50024a585311ccce269679ea639f4d451b5ed159 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BControlCreationFactory.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BControlCreationFactory.java @@ -1,45 +1,45 @@ -/** - * (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.bmotionstudio.gef.editor; - -import org.eclipse.core.runtime.CoreException; -import org.eclipse.gef.requests.CreationFactory; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class BControlCreationFactory implements CreationFactory { - - private Visualization visualization; - private String type; - - public BControlCreationFactory(String type, Visualization visualization) { - this.type = type; - this.visualization = visualization; - } - - @Override - public Object getNewObject() { - BControl control = null; - try { - IBControlService service = (IBControlService) BMotionEditorPlugin - .getControlServices().get(type) - .createExecutableExtension("service"); - control = service.createControl(visualization); - } catch (CoreException e) { - e.printStackTrace(); - } - // TODO: check if control == null - return control; - } - - @Override - public Object getObjectType() { - return BControl.class; - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.gef.requests.CreationFactory; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class BControlCreationFactory implements CreationFactory { + + private Visualization visualization; + private String type; + + public BControlCreationFactory(String type, Visualization visualization) { + this.type = type; + this.visualization = visualization; + } + + @Override + public Object getNewObject() { + BControl control = null; + try { + IBControlService service = (IBControlService) BMotionEditorPlugin + .getControlServices().get(type) + .createExecutableExtension("service"); + control = service.createControl(visualization); + } catch (CoreException e) { + e.printStackTrace(); + } + // TODO: check if control == null + return control; + } + + @Override + public Object getObjectType() { + return BControl.class; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionAbstractWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionAbstractWizard.java new file mode 100644 index 0000000000000000000000000000000000000000..0624b6f94d2250e8078965a8f8d9f0d86ed2990a --- /dev/null +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionAbstractWizard.java @@ -0,0 +1,26 @@ +/** + * (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.bmotionstudio.gef.editor; + +import org.eclipse.jface.wizard.Wizard; + +import de.bmotionstudio.gef.editor.model.BControl; + +public abstract class BMotionAbstractWizard extends Wizard { + + private BControl control; + + @Override + public boolean performFinish() { + return prepareToFinish(); + } + + public abstract String getName(); + + protected abstract Boolean prepareToFinish(); + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionEditorPlugin.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionEditorPlugin.java index 554ef61e747e60b621229afe145c0082055a7c25..471fb40d71ffa52e5d42c6ab6994b7b4518d6ff8 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionEditorPlugin.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionEditorPlugin.java @@ -1,221 +1,221 @@ -/** - * (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.bmotionstudio.gef.editor; - -import java.util.ArrayList; -import java.util.HashMap; - -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.Platform; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.ui.IWorkbenchPage; -import org.eclipse.ui.plugin.AbstractUIPlugin; -import org.osgi.framework.BundleContext; - -import com.thoughtworks.xstream.XStream; - -import de.bmotionstudio.gef.editor.internal.BControlListConverter; -import de.bmotionstudio.gef.editor.model.BConnection; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.BControlList; -import de.bmotionstudio.gef.editor.model.BMotionGuide; -import de.bmotionstudio.gef.editor.model.Visualization; - -/** - * The activator class controls the plug-in life cycle - */ -public class BMotionEditorPlugin extends AbstractUIPlugin { - - // The plug-in ID - public static final String PLUGIN_ID = "de.bmotionstudio.gef.editor"; - - public static final String FILEEXT_STUDIO = "bmso"; - - // The shared instance - private static BMotionEditorPlugin plugin; - - private static HashMap<String, IConfigurationElement> controlExtensions = new HashMap<String, IConfigurationElement>(); - - private static HashMap<String, IConfigurationElement> observerExtensions = new HashMap<String, IConfigurationElement>(); - - private static HashMap<String, IConfigurationElement> schedulerExtensions = new HashMap<String, IConfigurationElement>(); - - private static HashMap<String, IConfigurationElement> controlServices = new HashMap<String, IConfigurationElement>(); - - IExtensionRegistry registry = Platform.getExtensionRegistry(); - - static BMotionStudioEditorPage activeBMotionStudioEditor = null; - - /** - * The constructor - */ - public BMotionEditorPlugin() { - } - - /* - * (non-Javadoc) - * - * @see - * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext - * ) - */ - @Override - public void start(final BundleContext context) throws Exception { - super.start(context); - plugin = this; - initExtensionClasses(); - } - - /* - * (non-Javadoc) - * - * @see - * org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext - * ) - */ - @Override - public void stop(final BundleContext context) throws Exception { - plugin = null; - super.stop(context); - } - - /** - * Returns the shared instance - * - * @return the shared instance - */ - public static BMotionEditorPlugin getDefault() { - return plugin; - } - - /** - * Returns an image descriptor for the image file at the given plug-in - * relative path - * - * @param path - * the path - * @return the image descriptor - */ - public static ImageDescriptor getImageDescriptor(final String path) { - return imageDescriptorFromPlugin(PLUGIN_ID, path); - } - - /** - * Get the active workbench page. - * - * @return current active workbench page - */ - public static IWorkbenchPage getActivePage() { - return getDefault().internalGetActivePage(); - } - - /** - * Get the active editor. - * - * @return current active editor - */ - public static BMotionStudioEditor getActiveEditor() { - if (getActivePage() != null) { - if (getActivePage().getActiveEditor() instanceof BMotionStudioEditor) - return (BMotionStudioEditor) getActivePage().getActiveEditor(); - } - return null; - } - - /** - * Getting the current active page from the active workbench window. - * <p> - * - * @return current active workbench page - */ - private IWorkbenchPage internalGetActivePage() { - return getWorkbench().getActiveWorkbenchWindow().getActivePage(); - } - - private void initExtensionClass(String extensionPointID, - ArrayList<String> elementIDs, String getAttribute, - HashMap<String, IConfigurationElement> hashMap) { - - IExtensionPoint extensionPoint = registry - .getExtensionPoint(extensionPointID); - for (IExtension extension : extensionPoint.getExtensions()) { - - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if (elementIDs.contains(configurationElement.getName())) { - - String atr = configurationElement - .getAttribute(getAttribute); - - hashMap.put(atr, configurationElement); - - } - - } - - } - - } - - private void initExtensionClasses() { - - ArrayList<String> elementIDs = new ArrayList<String>(); - elementIDs.add("control"); - initExtensionClass("de.bmotionstudio.gef.editor.control", elementIDs, - "id", controlExtensions); - - elementIDs.clear(); - elementIDs.add("control"); - initExtensionClass("de.bmotionstudio.gef.editor.control", elementIDs, - "id", controlServices); - - elementIDs.clear(); - elementIDs.add("observer"); - initExtensionClass("de.bmotionstudio.gef.editor.observer", elementIDs, - "class", observerExtensions); - - elementIDs.clear(); - elementIDs.add("schedulerEvent"); - initExtensionClass("de.bmotionstudio.gef.editor.schedulerEvent", - elementIDs, "class", schedulerExtensions); - - } - - public static IConfigurationElement getControlExtension(String ident) { - return controlExtensions.get(ident); - } - - public static IConfigurationElement getObserverExtension(String ident) { - return observerExtensions.get(ident); - } - - public static IConfigurationElement getSchedulerExtension(String ident) { - return schedulerExtensions.get(ident); - } - - public static HashMap<String, IConfigurationElement> getSchedulerExtensions() { - return schedulerExtensions; - } - - public static HashMap<String, IConfigurationElement> getControlServices() { - return controlServices; - } - - public static void setAliases(XStream xstream) { - xstream.registerConverter(new BControlListConverter()); - xstream.alias("control", BControl.class); - xstream.alias("visualization", Visualization.class); - xstream.alias("guide", BMotionGuide.class); - xstream.alias("connection", BConnection.class); - xstream.alias("children", BControlList.class); - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.Platform; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.osgi.framework.BundleContext; + +import com.thoughtworks.xstream.XStream; + +import de.bmotionstudio.gef.editor.internal.BControlListConverter; +import de.bmotionstudio.gef.editor.model.BConnection; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.BControlList; +import de.bmotionstudio.gef.editor.model.BMotionGuide; +import de.bmotionstudio.gef.editor.model.Visualization; + +/** + * The activator class controls the plug-in life cycle + */ +public class BMotionEditorPlugin extends AbstractUIPlugin { + + // The plug-in ID + public static final String PLUGIN_ID = "de.bmotionstudio.gef.editor"; + + public static final String FILEEXT_STUDIO = "bmso"; + + // The shared instance + private static BMotionEditorPlugin plugin; + + private static HashMap<String, IConfigurationElement> controlExtensions = new HashMap<String, IConfigurationElement>(); + + private static HashMap<String, IConfigurationElement> observerExtensions = new HashMap<String, IConfigurationElement>(); + + private static HashMap<String, IConfigurationElement> schedulerExtensions = new HashMap<String, IConfigurationElement>(); + + private static HashMap<String, IConfigurationElement> controlServices = new HashMap<String, IConfigurationElement>(); + + IExtensionRegistry registry = Platform.getExtensionRegistry(); + + static BMotionStudioEditorPage activeBMotionStudioEditor = null; + + /** + * The constructor + */ + public BMotionEditorPlugin() { + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext + * ) + */ + @Override + public void start(final BundleContext context) throws Exception { + super.start(context); + plugin = this; + initExtensionClasses(); + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext + * ) + */ + @Override + public void stop(final BundleContext context) throws Exception { + plugin = null; + super.stop(context); + } + + /** + * Returns the shared instance + * + * @return the shared instance + */ + public static BMotionEditorPlugin getDefault() { + return plugin; + } + + /** + * Returns an image descriptor for the image file at the given plug-in + * relative path + * + * @param path + * the path + * @return the image descriptor + */ + public static ImageDescriptor getImageDescriptor(final String path) { + return imageDescriptorFromPlugin(PLUGIN_ID, path); + } + + /** + * Get the active workbench page. + * + * @return current active workbench page + */ + public static IWorkbenchPage getActivePage() { + return getDefault().internalGetActivePage(); + } + + /** + * Get the active editor. + * + * @return current active editor + */ + public static BMotionStudioEditor getActiveEditor() { + if (getActivePage() != null) { + if (getActivePage().getActiveEditor() instanceof BMotionStudioEditor) + return (BMotionStudioEditor) getActivePage().getActiveEditor(); + } + return null; + } + + /** + * Getting the current active page from the active workbench window. + * <p> + * + * @return current active workbench page + */ + private IWorkbenchPage internalGetActivePage() { + return getWorkbench().getActiveWorkbenchWindow().getActivePage(); + } + + private void initExtensionClass(String extensionPointID, + ArrayList<String> elementIDs, String getAttribute, + HashMap<String, IConfigurationElement> hashMap) { + + IExtensionPoint extensionPoint = registry + .getExtensionPoint(extensionPointID); + for (IExtension extension : extensionPoint.getExtensions()) { + + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if (elementIDs.contains(configurationElement.getName())) { + + String atr = configurationElement + .getAttribute(getAttribute); + + hashMap.put(atr, configurationElement); + + } + + } + + } + + } + + private void initExtensionClasses() { + + ArrayList<String> elementIDs = new ArrayList<String>(); + elementIDs.add("control"); + initExtensionClass("de.bmotionstudio.gef.editor.control", elementIDs, + "id", controlExtensions); + + elementIDs.clear(); + elementIDs.add("control"); + initExtensionClass("de.bmotionstudio.gef.editor.control", elementIDs, + "id", controlServices); + + elementIDs.clear(); + elementIDs.add("observer"); + initExtensionClass("de.bmotionstudio.gef.editor.observer", elementIDs, + "class", observerExtensions); + + elementIDs.clear(); + elementIDs.add("schedulerEvent"); + initExtensionClass("de.bmotionstudio.gef.editor.schedulerEvent", + elementIDs, "class", schedulerExtensions); + + } + + public static IConfigurationElement getControlExtension(String ident) { + return controlExtensions.get(ident); + } + + public static IConfigurationElement getObserverExtension(String ident) { + return observerExtensions.get(ident); + } + + public static IConfigurationElement getSchedulerExtension(String ident) { + return schedulerExtensions.get(ident); + } + + public static HashMap<String, IConfigurationElement> getSchedulerExtensions() { + return schedulerExtensions; + } + + public static HashMap<String, IConfigurationElement> getControlServices() { + return controlServices; + } + + public static void setAliases(XStream xstream) { + xstream.registerConverter(new BControlListConverter()); + xstream.alias("control", BControl.class); + xstream.alias("visualization", Visualization.class); + xstream.alias("guide", BMotionGuide.class); + xstream.alias("connection", BConnection.class); + xstream.alias("children", BControlList.class); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioEditorPage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioEditorPage.java index 3caccfa2fa3e71f4136f9672be62a451150ecf89..42bd71995f9fb48c2e2577ce96b83326065e1b6e 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioEditorPage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioEditorPage.java @@ -1,810 +1,810 @@ -/** - * (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.bmotionstudio.gef.editor; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.OutputStream; -import java.io.OutputStreamWriter; -import java.util.ArrayList; -import java.util.EventObject; -import java.util.HashMap; -import java.util.Map; - -import org.eclipse.core.resources.IFile; -import org.eclipse.core.resources.IMarker; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.IProgressMonitor; -import org.eclipse.core.runtime.Platform; -import org.eclipse.draw2d.FigureCanvas; -import org.eclipse.draw2d.LightweightSystem; -import org.eclipse.draw2d.PositionConstants; -import org.eclipse.draw2d.Viewport; -import org.eclipse.draw2d.parts.ScrollableThumbnail; -import org.eclipse.gef.ContextMenuProvider; -import org.eclipse.gef.DefaultEditDomain; -import org.eclipse.gef.KeyHandler; -import org.eclipse.gef.KeyStroke; -import org.eclipse.gef.LayerConstants; -import org.eclipse.gef.MouseWheelHandler; -import org.eclipse.gef.MouseWheelZoomHandler; -import org.eclipse.gef.SnapToGeometry; -import org.eclipse.gef.SnapToGrid; -import org.eclipse.gef.commands.CommandStack; -import org.eclipse.gef.commands.CommandStackListener; -import org.eclipse.gef.dnd.TemplateTransferDragSourceListener; -import org.eclipse.gef.editparts.ScalableRootEditPart; -import org.eclipse.gef.editparts.ZoomManager; -import org.eclipse.gef.palette.PaletteRoot; -import org.eclipse.gef.rulers.RulerProvider; -import org.eclipse.gef.ui.actions.ActionRegistry; -import org.eclipse.gef.ui.actions.GEFActionConstants; -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.gef.ui.actions.ToggleGridAction; -import org.eclipse.gef.ui.actions.ToggleRulerVisibilityAction; -import org.eclipse.gef.ui.actions.ToggleSnapToGeometryAction; -import org.eclipse.gef.ui.actions.ZoomInAction; -import org.eclipse.gef.ui.actions.ZoomOutAction; -import org.eclipse.gef.ui.palette.FlyoutPaletteComposite; -import org.eclipse.gef.ui.palette.PaletteViewer; -import org.eclipse.gef.ui.palette.PaletteViewerProvider; -import org.eclipse.gef.ui.parts.ContentOutlinePage; -import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette; -import org.eclipse.gef.ui.parts.GraphicalViewerKeyHandler; -import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer; -import org.eclipse.gef.ui.parts.SelectionSynchronizer; -import org.eclipse.gef.ui.parts.TreeViewer; -import org.eclipse.gef.ui.rulers.RulerComposite; -import org.eclipse.jface.action.Action; -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.viewers.ISelection; -import org.eclipse.swt.SWT; -import org.eclipse.swt.custom.SashForm; -import org.eclipse.swt.events.DisposeEvent; -import org.eclipse.swt.events.DisposeListener; -import org.eclipse.swt.widgets.Canvas; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Tree; -import org.eclipse.swt.widgets.TreeItem; -import org.eclipse.ui.IActionBars; -import org.eclipse.ui.IEditorInput; -import org.eclipse.ui.IEditorPart; -import org.eclipse.ui.IEditorSite; -import org.eclipse.ui.IFileEditorInput; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.PartInitException; -import org.eclipse.ui.actions.ActionFactory; -import org.eclipse.ui.part.IPageSite; -import org.eclipse.ui.views.contentoutline.IContentOutlinePage; -import org.eclipse.ui.views.properties.IPropertySheetPage; - -import com.thoughtworks.xstream.XStream; - -import de.bmotionstudio.gef.editor.action.CopyAction; -import de.bmotionstudio.gef.editor.action.ObserverAction; -import de.bmotionstudio.gef.editor.action.PasteAction; -import de.bmotionstudio.gef.editor.action.SchedulerEventAction; -import de.bmotionstudio.gef.editor.internal.BControlTransferDropTargetListener; -import de.bmotionstudio.gef.editor.library.AttributeTransferDropTargetListener; -import de.bmotionstudio.gef.editor.model.BMotionRuler; -import de.bmotionstudio.gef.editor.model.BMotionRulerProvider; -import de.bmotionstudio.gef.editor.model.Visualization; -import de.bmotionstudio.gef.editor.part.AppEditPartFactory; -import de.bmotionstudio.gef.editor.part.AppTreeEditPartFactory; - -public class BMotionStudioEditorPage extends GraphicalEditorWithFlyoutPalette { - - public final static String ID = "de.bmotionstudio.gef.editor"; - - private boolean isDirty; - - private KeyHandler sharedKeyHandler; - - private Visualization visualization; - - private RulerComposite rulerComp; - - // private BControl editArea; - - private BMotionStudioEditor bmotionStudioEditor; - - private BMotionSelectionSynchronizer bmotionSelectionSynchronizer; - - /** Palette component, holding the tools and b-controls. */ - private PaletteRoot palette; - - public BMotionStudioEditorPage(Visualization visualization, - BMotionStudioEditor bmotionStudioEditor) { - this.visualization = visualization; - this.bmotionStudioEditor = bmotionStudioEditor; - setEditDomain(new DefaultEditDomain(this)); - } - - @Override - public void selectionChanged(IWorkbenchPart part, ISelection selection) { - // If not the active editor, ignore selection changed. - if (getBMotionStudioEditor().equals( - getSite().getPage().getActiveEditor())) - updateActions(getSelectionActions()); - } - - /** - * @see org.eclipse.ui.IEditorPart#init(IEditorSite, IEditorInput) - **/ - public void init(IEditorSite iSite, IEditorInput iInput) - throws PartInitException { - super.init(iSite, iInput); - setSite(iSite); - // add CommandStackListener - getCommandStack().addCommandStackListener(getCommandStackListener()); - } - - /** - * @see org.eclipse.gef.ui.parts.GraphicalEditor#initializeGraphicalViewer() - **/ - protected void initializeGraphicalViewer() { - - super.initializeGraphicalViewer(); - - getGraphicalViewer().setContents(getVisualization()); - - getGraphicalViewer().addDropTargetListener( - new BControlTransferDropTargetListener(getGraphicalViewer(), - visualization)); - getGraphicalViewer().addDropTargetListener( - new AttributeTransferDropTargetListener(getGraphicalViewer(), - getSite().getPart())); - - getPalettePreferences().setPaletteState( - FlyoutPaletteComposite.STATE_PINNED_OPEN); - - } - - @Override - protected PaletteViewerProvider createPaletteViewerProvider() { - return new PaletteViewerProvider(getEditDomain()) { - protected void configurePaletteViewer(PaletteViewer viewer) { - super.configurePaletteViewer(viewer); - viewer.addDragSourceListener(new TemplateTransferDragSourceListener( - viewer)); - } - - protected void hookPaletteViewer(PaletteViewer viewer) { - super.hookPaletteViewer(viewer); - } - }; - } - - /** - * @see org.eclipse.ui.IEditorPart#isSaveAsAllowed() - **/ - public boolean isSaveAsAllowed() { - return true; - } - - /** - * Creates an appropriate output stream and writes the activity diagram out - * to this stream. - * - * @param os - * the base output stream - * @throws IOException - */ - protected void createOutputStream(OutputStream os) throws IOException { - OutputStreamWriter writer = new OutputStreamWriter(os, "UTF8"); - XStream xstream = new XStream(); - BMotionEditorPlugin.setAliases(xstream); - xstream.toXML(visualization, writer); - } - - /** - * @see org.eclipse.ui.IEditorPart#doSave(IProgressMonitor) - **/ - public void doSave(IProgressMonitor iMonitor) { - ByteArrayOutputStream out = new ByteArrayOutputStream(); - try { - saveProperties(); - createOutputStream(out); - IFile file = ((IFileEditorInput) getEditorInput()).getFile(); - file.setContents(new ByteArrayInputStream(out.toByteArray()), true, - false, iMonitor); - getCommandStack().markSaveLocation(); - } catch (CoreException ce) { - ce.printStackTrace(); - } catch (IOException ioe) { - ioe.printStackTrace(); - } - } - - /* - * (non-Javadoc) - * - * @see org.eclipse.ui.IWorkbenchPart#dispose() - */ - public void dispose() { - // remove CommandStackListener - getCommandStack().removeCommandStackListener(getCommandStackListener()); - // important: always call super implementation of dispose - super.dispose(); - } - - /** - * @see org.eclipse.ui.IEditorPart#doSaveAs() - **/ - public void doSaveAs() { - // Nothing to do here, this is never allowed - throw new IllegalAccessError("No way to enter this method."); - } - - @Override - public Object getAdapter(@SuppressWarnings("rawtypes") Class type) { - if (type == ZoomManager.class) - return ((ScalableRootEditPart) getGraphicalViewer() - .getRootEditPart()).getZoomManager(); - if (type == IContentOutlinePage.class) - return new BMotionOutlinePage(); - if (type == IPropertySheetPage.class) { - BMotionStudioPropertySheet page = new BMotionStudioPropertySheet(); - page.setRootEntry(new CustomSortPropertySheetEntry( - getCommandStack())); - return page; - } - return super.getAdapter(type); - } - - /** - * @see org.eclipse.ui.IEditorPart#gotoMarker(IMarker) - **/ - public void gotoMarker(IMarker iMarker) { - } - - /** - * Returns the KeyHandler with common bindings for both the Outline and - * Graphical Views. For example, delete is a common action. - */ - protected KeyHandler getCommonKeyHandler() { - if (sharedKeyHandler == null) { - sharedKeyHandler = new KeyHandler(); - sharedKeyHandler.put( - KeyStroke.getPressed(SWT.F2, 0), - getActionRegistry().getAction( - GEFActionConstants.DIRECT_EDIT)); - sharedKeyHandler - .put(KeyStroke.getPressed(SWT.DEL, 127, 0), - getActionRegistry().getAction( - ActionFactory.DELETE.getId())); - - sharedKeyHandler.put(KeyStroke.getPressed('+', SWT.KEYPAD_ADD, 0), - getActionRegistry().getAction(GEFActionConstants.ZOOM_IN)); - - sharedKeyHandler.put( - KeyStroke.getPressed('-', SWT.KEYPAD_SUBTRACT, 0), - getActionRegistry().getAction(GEFActionConstants.ZOOM_OUT)); - - sharedKeyHandler.put( - KeyStroke.getPressed(SWT.F2, 0), - getActionRegistry().getAction( - GEFActionConstants.DIRECT_EDIT)); - } - return sharedKeyHandler; - } - - public void setDirty(boolean dirty) { - if (isDirty() != dirty) { - isDirty = dirty; - firePropertyChange(IEditorPart.PROP_DIRTY); - } - } - - /* - * @see EditorPart#isDirty - */ - @Override - public boolean isDirty() { - return isDirty; - } - - @SuppressWarnings("unchecked") - public void createActions() { - - super.createActions(); - - ActionRegistry registry = getActionRegistry(); - - installCustomActions(); - - IAction action = new CopyAction(this); - registry.registerAction(action); - getSelectionActions().add(action.getId()); - - action = new PasteAction(this); - registry.registerAction(action); - getSelectionActions().add(action.getId()); - - installObserverActions(); - installSchedulerActions(); - - } - - @SuppressWarnings("unchecked") - private void installObserverActions() { - - IAction action; - ActionRegistry registry = getActionRegistry(); - - IExtensionRegistry reg = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = reg - .getExtensionPoint("de.bmotionstudio.gef.editor.observer"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("observer".equals(configurationElement.getName())) { - - String observerClassName = configurationElement - .getAttribute("class"); - - action = new ObserverAction(this); - action.setId("de.bmotionstudio.gef.editor.observerAction." - + observerClassName); - ((ObserverAction) action).setClassName(observerClassName); - registry.registerAction(action); - getSelectionActions().add( - "de.bmotionstudio.gef.editor.observerAction." - + observerClassName); - - } - - } - - } - - } - - @SuppressWarnings("unchecked") - private void installSchedulerActions() { - - IAction action; - ActionRegistry registry = getActionRegistry(); - - IExtensionRegistry reg = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = reg - .getExtensionPoint("de.bmotionstudio.gef.editor.schedulerEvent"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("schedulerEvent".equals(configurationElement.getName())) { - - String sClassName = configurationElement - .getAttribute("class"); - - action = new SchedulerEventAction(this); - action.setId("de.bmotionstudio.gef.editor.SchedulerEventAction." - + sClassName); - ((SchedulerEventAction) action).setClassName(sClassName); - registry.registerAction(action); - getSelectionActions().add( - "de.bmotionstudio.gef.editor.SchedulerEventAction." - + sClassName); - - } - - } - - } - - } - - @SuppressWarnings("unchecked") - private void installCustomActions() { - - ActionRegistry registry = getActionRegistry(); - - IExtensionRegistry reg = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = reg - .getExtensionPoint("de.bmotionstudio.gef.editor.installActions"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("action".equals(configurationElement.getName())) { - - try { - - IInstallActions installActionsClass = (IInstallActions) configurationElement - .createExecutableExtension("class"); - - installActionsClass.installActions(this); - HashMap<String, Action> actionMap = installActionsClass - .getActionMap(); - - for (Map.Entry<String, Action> entry : actionMap - .entrySet()) { - - registry.registerAction(entry.getValue()); - if (entry.getValue() instanceof SelectionAction) - getSelectionActions().add(entry.getKey()); - - } - - } catch (final CoreException e) { - e.printStackTrace(); - } - - } - - } - - } - - } - - protected Control getGraphicalControl() { - return rulerComp; - } - - protected void createGraphicalViewer(Composite parent) { - rulerComp = new RulerComposite(parent, SWT.NONE); - super.createGraphicalViewer(rulerComp); - rulerComp - .setGraphicalViewer((ScrollingGraphicalViewer) getGraphicalViewer()); - } - - /** - * @see org.eclipse.gef.ui.parts.GraphicalEditor#configureGraphicalViewer() - **/ - protected void configureGraphicalViewer() { - - double[] zoomLevels; - - super.configureGraphicalViewer(); - ScrollingGraphicalViewer viewer = (ScrollingGraphicalViewer) getGraphicalViewer(); - - viewer.setEditPartFactory(new AppEditPartFactory()); - - ScalableRootEditPart rootEditPart = new ScalableRootEditPart(); - viewer.setRootEditPart(rootEditPart); - - ZoomManager manager = rootEditPart.getZoomManager(); - getActionRegistry().registerAction(new ZoomInAction(manager)); - getActionRegistry().registerAction(new ZoomOutAction(manager)); - - zoomLevels = new double[] { 0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, - 4.0, 5.0, 10.0, 20.0 }; - manager.setZoomLevels(zoomLevels); - ArrayList<String> zoomContributions = new ArrayList<String>(); - zoomContributions.add(ZoomManager.FIT_ALL); - zoomContributions.add(ZoomManager.FIT_HEIGHT); - zoomContributions.add(ZoomManager.FIT_WIDTH); - manager.setZoomLevelContributions(zoomContributions); - - viewer.setProperty(MouseWheelHandler.KeyGenerator.getKey(SWT.NONE), - MouseWheelZoomHandler.SINGLETON); - - // viewer.setKeyHandler(keyHandler); - - viewer.setKeyHandler(new GraphicalViewerKeyHandler(viewer) - .setParent(getCommonKeyHandler())); - - loadProperties(); - - getActionRegistry().registerAction( - new ToggleRulerVisibilityAction(getGraphicalViewer())); - getActionRegistry().registerAction( - new ToggleSnapToGeometryAction(getGraphicalViewer())); - getActionRegistry().registerAction( - new ToggleGridAction(getGraphicalViewer())); - - ContextMenuProvider provider = new AppContextMenuProvider(viewer, - getActionRegistry()); - viewer.setContextMenu(provider); - - } - - protected void loadProperties() { - - // Ruler properties - BMotionRuler ruler = getVisualization() - .getRuler(PositionConstants.WEST); - RulerProvider provider = null; - if (ruler != null) { - provider = new BMotionRulerProvider(ruler); - } - getGraphicalViewer().setProperty(RulerProvider.PROPERTY_VERTICAL_RULER, - provider); - ruler = getVisualization().getRuler(PositionConstants.NORTH); - provider = null; - if (ruler != null) { - provider = new BMotionRulerProvider(ruler); - } - getGraphicalViewer().setProperty( - RulerProvider.PROPERTY_HORIZONTAL_RULER, provider); - getGraphicalViewer().setProperty( - RulerProvider.PROPERTY_RULER_VISIBILITY, - getVisualization().getRulerVisibility()); - getGraphicalViewer().setProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED, - getVisualization().isSnapToGeometryEnabled()); - getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_ENABLED, - getVisualization().isGridEnabled()); - getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_VISIBLE, - getVisualization().isGridEnabled()); - - getPalettePreferences().setPaletteState( - FlyoutPaletteComposite.STATE_PINNED_OPEN); - - } - - protected void saveProperties() { - getVisualization().setRulerVisibility( - ((Boolean) getGraphicalViewer().getProperty( - RulerProvider.PROPERTY_RULER_VISIBILITY)) - .booleanValue()); - getVisualization().setGridEnabled( - ((Boolean) getGraphicalViewer().getProperty( - SnapToGrid.PROPERTY_GRID_ENABLED)).booleanValue()); - getVisualization().setSnapToGeometry( - ((Boolean) getGraphicalViewer().getProperty( - SnapToGeometry.PROPERTY_SNAP_ENABLED)).booleanValue()); - } - - /** - * The <code>CommandStackListener</code> that listens for - * <code>CommandStack </code>changes. - */ - private CommandStackListener commandStackListener = new CommandStackListener() { - public void commandStackChanged(EventObject event) { - setDirty(getCommandStack().isDirty()); - } - }; - - /** - * Returns the <code>CommandStack</code> of this editor's - * <code>EditDomain</code>. - * - * @return the <code>CommandStack</code> - */ - @Override - public CommandStack getCommandStack() { - return getEditDomain().getCommandStack(); - } - - /** - * Returns the <code>CommandStackListener</code>. - * - * @return the <code>CommandStackListener</code> - */ - protected CommandStackListener getCommandStackListener() { - return commandStackListener; - } - - /** - * Returns the palette root. - */ - protected PaletteRoot getPaletteRoot() { - if (palette == null) { - palette = new EditorPaletteFactory().createPalette(visualization); - } - return palette; - } - - protected FigureCanvas getEditor() { - return (FigureCanvas) getGraphicalViewer().getControl(); - } - - @Override - public SelectionSynchronizer getSelectionSynchronizer() { - if (bmotionSelectionSynchronizer == null) - bmotionSelectionSynchronizer = new BMotionSelectionSynchronizer( - bmotionStudioEditor); - return bmotionSelectionSynchronizer; - } - - protected class BMotionOutlinePage extends ContentOutlinePage { - - private SashForm sash; - - private ScrollableThumbnail thumbnail; - private DisposeListener disposeListener; - - public BMotionOutlinePage() { - super(new TreeViewer()); - } - - public void init(IPageSite pageSite) { - super.init(pageSite); - IActionBars bars = pageSite.getActionBars(); - ActionRegistry ar = getActionRegistry(); - bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), - ar.getAction(ActionFactory.UNDO.getId())); - bars.setGlobalActionHandler(ActionFactory.REDO.getId(), - ar.getAction(ActionFactory.REDO.getId())); - bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), - ar.getAction(ActionFactory.DELETE.getId())); - bars.setGlobalActionHandler(ActionFactory.COPY.getId(), - ar.getAction(ActionFactory.COPY.getId())); - bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), - ar.getAction(ActionFactory.PASTE.getId())); - buildCustomActions(bars, ar); - bars.updateActionBars(); - } - - protected void configureOutlineViewer() { - getViewer().setEditDomain(getEditDomain()); - getViewer().setEditPartFactory(new AppTreeEditPartFactory()); - ContextMenuProvider provider = new AppContextMenuProvider( - getViewer(), getActionRegistry()); - getViewer().setContextMenu(provider); - getViewer().setKeyHandler(getCommonKeyHandler()); - } - - protected void initializeOutlineViewer() { - setContents(getVisualization()); - } - - public void setContents(Object contents) { - getViewer().setContents(contents); - } - - protected void hookOutlineViewer() { - getSelectionSynchronizer().addViewer(getViewer()); - } - - protected void unhookOutlineViewer() { - getSelectionSynchronizer().removeViewer(getViewer()); - if (getGraphicalViewer().getControl() != null - && !getGraphicalViewer().getControl().isDisposed()) - getGraphicalViewer().getControl().removeDisposeListener( - disposeListener); - } - - @Override - public void createControl(Composite parent) { - initializeOverview(parent); - getGraphicalViewer().getControl().addDisposeListener( - disposeListener); - configureOutlineViewer(); - hookOutlineViewer(); - initializeOutlineViewer(); - createMenu(); - } - - /** - * - */ - private void createMenu() { - - Action expandAllAction = new Action("Expand All") { - - @Override - public void run() { - for (TreeItem item : ((Tree) getViewer().getControl()) - .getItems()) { - item.setExpanded(true); - } - } - - }; - - Action collapseAllAction = new Action("Collapse All") { - - @Override - public void run() { - for (TreeItem item : ((Tree) getViewer().getControl()) - .getItems()) { - item.setExpanded(false); - } - } - - }; - // collapseAllAction - // .setImageDescriptor(ImageDescriptor - // .createFromImage(PlatformUI - // .getWorkbench() - // .getSharedImages() - // .getImage( - // ISharedImages.IMG_ELCL_COLLAPSEALL))); - - getSite().getActionBars().getMenuManager().add(expandAllAction); - getSite().getActionBars().getMenuManager().add(collapseAllAction); - - } - - protected void initializeOverview(Composite parent) { - sash = new SashForm(parent, SWT.VERTICAL); - - getViewer().createControl(sash); - - Canvas canvas = new Canvas(sash, SWT.BORDER); - canvas.setBackground(Display.getDefault().getSystemColor( - SWT.COLOR_WHITE)); - LightweightSystem lws = new LightweightSystem(canvas); - - thumbnail = new ScrollableThumbnail( - (Viewport) ((ScalableRootEditPart) getGraphicalViewer() - .getRootEditPart()).getFigure()); - thumbnail.setSource(((ScalableRootEditPart) getGraphicalViewer() - .getRootEditPart()) - .getLayer(LayerConstants.PRINTABLE_LAYERS)); - - lws.setContents(thumbnail); - - disposeListener = new DisposeListener() { - public void widgetDisposed(DisposeEvent e) { - if (thumbnail != null) { - thumbnail.deactivate(); - thumbnail = null; - } - } - }; - } - - public Control getControl() { - return sash; - } - - public void dispose() { - unhookOutlineViewer(); - super.dispose(); - } - - } - - private void buildCustomActions(IActionBars bars, ActionRegistry ar) { - - IExtensionRegistry reg = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = reg - .getExtensionPoint("de.bmotionstudio.gef.editor.installMenu"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("menu".equals(configurationElement.getName())) { - - try { - - IInstallMenu installMenuClass = (IInstallMenu) configurationElement - .createExecutableExtension("class"); - - installMenuClass.installBar(bars, getActionRegistry()); - - } catch (final CoreException e) { - e.printStackTrace(); - } - - } - - } - - } - - } - - public Visualization getVisualization() { - return visualization; - } - - public void setBMotionStudioEditor(BMotionStudioEditor bmotionStudioEditor) { - this.bmotionStudioEditor = bmotionStudioEditor; - } - - public BMotionStudioEditor getBMotionStudioEditor() { - return bmotionStudioEditor; - } - - public ScalableRootEditPart getRootEditPart() { - return (ScalableRootEditPart) getGraphicalViewer().getRootEditPart(); - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.util.ArrayList; +import java.util.EventObject; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IMarker; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.Platform; +import org.eclipse.draw2d.FigureCanvas; +import org.eclipse.draw2d.LightweightSystem; +import org.eclipse.draw2d.PositionConstants; +import org.eclipse.draw2d.Viewport; +import org.eclipse.draw2d.parts.ScrollableThumbnail; +import org.eclipse.gef.ContextMenuProvider; +import org.eclipse.gef.DefaultEditDomain; +import org.eclipse.gef.KeyHandler; +import org.eclipse.gef.KeyStroke; +import org.eclipse.gef.LayerConstants; +import org.eclipse.gef.MouseWheelHandler; +import org.eclipse.gef.MouseWheelZoomHandler; +import org.eclipse.gef.SnapToGeometry; +import org.eclipse.gef.SnapToGrid; +import org.eclipse.gef.commands.CommandStack; +import org.eclipse.gef.commands.CommandStackListener; +import org.eclipse.gef.dnd.TemplateTransferDragSourceListener; +import org.eclipse.gef.editparts.ScalableRootEditPart; +import org.eclipse.gef.editparts.ZoomManager; +import org.eclipse.gef.palette.PaletteRoot; +import org.eclipse.gef.rulers.RulerProvider; +import org.eclipse.gef.ui.actions.ActionRegistry; +import org.eclipse.gef.ui.actions.GEFActionConstants; +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.gef.ui.actions.ToggleGridAction; +import org.eclipse.gef.ui.actions.ToggleRulerVisibilityAction; +import org.eclipse.gef.ui.actions.ToggleSnapToGeometryAction; +import org.eclipse.gef.ui.actions.ZoomInAction; +import org.eclipse.gef.ui.actions.ZoomOutAction; +import org.eclipse.gef.ui.palette.FlyoutPaletteComposite; +import org.eclipse.gef.ui.palette.PaletteViewer; +import org.eclipse.gef.ui.palette.PaletteViewerProvider; +import org.eclipse.gef.ui.parts.ContentOutlinePage; +import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette; +import org.eclipse.gef.ui.parts.GraphicalViewerKeyHandler; +import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer; +import org.eclipse.gef.ui.parts.SelectionSynchronizer; +import org.eclipse.gef.ui.parts.TreeViewer; +import org.eclipse.gef.ui.rulers.RulerComposite; +import org.eclipse.jface.action.Action; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.SashForm; +import org.eclipse.swt.events.DisposeEvent; +import org.eclipse.swt.events.DisposeListener; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Tree; +import org.eclipse.swt.widgets.TreeItem; +import org.eclipse.ui.IActionBars; +import org.eclipse.ui.IEditorInput; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IEditorSite; +import org.eclipse.ui.IFileEditorInput; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.actions.ActionFactory; +import org.eclipse.ui.part.IPageSite; +import org.eclipse.ui.views.contentoutline.IContentOutlinePage; +import org.eclipse.ui.views.properties.IPropertySheetPage; + +import com.thoughtworks.xstream.XStream; + +import de.bmotionstudio.gef.editor.action.CopyAction; +import de.bmotionstudio.gef.editor.action.OpenObserverAction; +import de.bmotionstudio.gef.editor.action.PasteAction; +import de.bmotionstudio.gef.editor.action.OpenSchedulerEventAction; +import de.bmotionstudio.gef.editor.internal.BControlTransferDropTargetListener; +import de.bmotionstudio.gef.editor.library.AttributeTransferDropTargetListener; +import de.bmotionstudio.gef.editor.model.BMotionRuler; +import de.bmotionstudio.gef.editor.model.BMotionRulerProvider; +import de.bmotionstudio.gef.editor.model.Visualization; +import de.bmotionstudio.gef.editor.part.AppEditPartFactory; +import de.bmotionstudio.gef.editor.part.AppTreeEditPartFactory; + +public class BMotionStudioEditorPage extends GraphicalEditorWithFlyoutPalette { + + public final static String ID = "de.bmotionstudio.gef.editor"; + + private boolean isDirty; + + private KeyHandler sharedKeyHandler; + + private Visualization visualization; + + private RulerComposite rulerComp; + + // private BControl editArea; + + private BMotionStudioEditor bmotionStudioEditor; + + private BMotionSelectionSynchronizer bmotionSelectionSynchronizer; + + /** Palette component, holding the tools and b-controls. */ + private PaletteRoot palette; + + public BMotionStudioEditorPage(Visualization visualization, + BMotionStudioEditor bmotionStudioEditor) { + this.visualization = visualization; + this.bmotionStudioEditor = bmotionStudioEditor; + setEditDomain(new DefaultEditDomain(this)); + } + + @Override + public void selectionChanged(IWorkbenchPart part, ISelection selection) { + // If not the active editor, ignore selection changed. + if (getBMotionStudioEditor().equals( + getSite().getPage().getActiveEditor())) + updateActions(getSelectionActions()); + } + + /** + * @see org.eclipse.ui.IEditorPart#init(IEditorSite, IEditorInput) + **/ + public void init(IEditorSite iSite, IEditorInput iInput) + throws PartInitException { + super.init(iSite, iInput); + setSite(iSite); + // add CommandStackListener + getCommandStack().addCommandStackListener(getCommandStackListener()); + } + + /** + * @see org.eclipse.gef.ui.parts.GraphicalEditor#initializeGraphicalViewer() + **/ + protected void initializeGraphicalViewer() { + + super.initializeGraphicalViewer(); + + getGraphicalViewer().setContents(getVisualization()); + + getGraphicalViewer().addDropTargetListener( + new BControlTransferDropTargetListener(getGraphicalViewer(), + visualization)); + getGraphicalViewer().addDropTargetListener( + new AttributeTransferDropTargetListener(getGraphicalViewer(), + getSite().getPart())); + + getPalettePreferences().setPaletteState( + FlyoutPaletteComposite.STATE_PINNED_OPEN); + + } + + @Override + protected PaletteViewerProvider createPaletteViewerProvider() { + return new PaletteViewerProvider(getEditDomain()) { + protected void configurePaletteViewer(PaletteViewer viewer) { + super.configurePaletteViewer(viewer); + viewer.addDragSourceListener(new TemplateTransferDragSourceListener( + viewer)); + } + + protected void hookPaletteViewer(PaletteViewer viewer) { + super.hookPaletteViewer(viewer); + } + }; + } + + /** + * @see org.eclipse.ui.IEditorPart#isSaveAsAllowed() + **/ + public boolean isSaveAsAllowed() { + return true; + } + + /** + * Creates an appropriate output stream and writes the activity diagram out + * to this stream. + * + * @param os + * the base output stream + * @throws IOException + */ + protected void createOutputStream(OutputStream os) throws IOException { + OutputStreamWriter writer = new OutputStreamWriter(os, "UTF8"); + XStream xstream = new XStream(); + BMotionEditorPlugin.setAliases(xstream); + xstream.toXML(visualization, writer); + } + + /** + * @see org.eclipse.ui.IEditorPart#doSave(IProgressMonitor) + **/ + public void doSave(IProgressMonitor iMonitor) { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try { + saveProperties(); + createOutputStream(out); + IFile file = ((IFileEditorInput) getEditorInput()).getFile(); + file.setContents(new ByteArrayInputStream(out.toByteArray()), true, + false, iMonitor); + getCommandStack().markSaveLocation(); + } catch (CoreException ce) { + ce.printStackTrace(); + } catch (IOException ioe) { + ioe.printStackTrace(); + } + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.ui.IWorkbenchPart#dispose() + */ + public void dispose() { + // remove CommandStackListener + getCommandStack().removeCommandStackListener(getCommandStackListener()); + // important: always call super implementation of dispose + super.dispose(); + } + + /** + * @see org.eclipse.ui.IEditorPart#doSaveAs() + **/ + public void doSaveAs() { + // Nothing to do here, this is never allowed + throw new IllegalAccessError("No way to enter this method."); + } + + @Override + public Object getAdapter(@SuppressWarnings("rawtypes") Class type) { + if (type == ZoomManager.class) + return ((ScalableRootEditPart) getGraphicalViewer() + .getRootEditPart()).getZoomManager(); + if (type == IContentOutlinePage.class) + return new BMotionOutlinePage(); + if (type == IPropertySheetPage.class) { + BMotionStudioPropertySheet page = new BMotionStudioPropertySheet(); + page.setRootEntry(new CustomSortPropertySheetEntry( + getCommandStack())); + return page; + } + return super.getAdapter(type); + } + + /** + * @see org.eclipse.ui.IEditorPart#gotoMarker(IMarker) + **/ + public void gotoMarker(IMarker iMarker) { + } + + /** + * Returns the KeyHandler with common bindings for both the Outline and + * Graphical Views. For example, delete is a common action. + */ + protected KeyHandler getCommonKeyHandler() { + if (sharedKeyHandler == null) { + sharedKeyHandler = new KeyHandler(); + sharedKeyHandler.put( + KeyStroke.getPressed(SWT.F2, 0), + getActionRegistry().getAction( + GEFActionConstants.DIRECT_EDIT)); + sharedKeyHandler + .put(KeyStroke.getPressed(SWT.DEL, 127, 0), + getActionRegistry().getAction( + ActionFactory.DELETE.getId())); + + sharedKeyHandler.put(KeyStroke.getPressed('+', SWT.KEYPAD_ADD, 0), + getActionRegistry().getAction(GEFActionConstants.ZOOM_IN)); + + sharedKeyHandler.put( + KeyStroke.getPressed('-', SWT.KEYPAD_SUBTRACT, 0), + getActionRegistry().getAction(GEFActionConstants.ZOOM_OUT)); + + sharedKeyHandler.put( + KeyStroke.getPressed(SWT.F2, 0), + getActionRegistry().getAction( + GEFActionConstants.DIRECT_EDIT)); + } + return sharedKeyHandler; + } + + public void setDirty(boolean dirty) { + if (isDirty() != dirty) { + isDirty = dirty; + firePropertyChange(IEditorPart.PROP_DIRTY); + } + } + + /* + * @see EditorPart#isDirty + */ + @Override + public boolean isDirty() { + return isDirty; + } + + @SuppressWarnings("unchecked") + public void createActions() { + + super.createActions(); + + ActionRegistry registry = getActionRegistry(); + + installCustomActions(); + + IAction action = new CopyAction(this); + registry.registerAction(action); + getSelectionActions().add(action.getId()); + + action = new PasteAction(this); + registry.registerAction(action); + getSelectionActions().add(action.getId()); + + installObserverActions(); + installSchedulerActions(); + + } + + @SuppressWarnings("unchecked") + private void installObserverActions() { + + IAction action; + ActionRegistry registry = getActionRegistry(); + + IExtensionRegistry reg = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = reg + .getExtensionPoint("de.bmotionstudio.gef.editor.observer"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("observer".equals(configurationElement.getName())) { + + String observerClassName = configurationElement + .getAttribute("class"); + + action = new OpenObserverAction(this); + action.setId("de.bmotionstudio.gef.editor.observerAction." + + observerClassName); + ((OpenObserverAction) action).setClassName(observerClassName); + registry.registerAction(action); + getSelectionActions().add( + "de.bmotionstudio.gef.editor.observerAction." + + observerClassName); + + } + + } + + } + + } + + @SuppressWarnings("unchecked") + private void installSchedulerActions() { + + IAction action; + ActionRegistry registry = getActionRegistry(); + + IExtensionRegistry reg = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = reg + .getExtensionPoint("de.bmotionstudio.gef.editor.schedulerEvent"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("schedulerEvent".equals(configurationElement.getName())) { + + String sClassName = configurationElement + .getAttribute("class"); + + action = new OpenSchedulerEventAction(this); + action.setId("de.bmotionstudio.gef.editor.SchedulerEventAction." + + sClassName); + ((OpenSchedulerEventAction) action).setClassName(sClassName); + registry.registerAction(action); + getSelectionActions().add( + "de.bmotionstudio.gef.editor.SchedulerEventAction." + + sClassName); + + } + + } + + } + + } + + @SuppressWarnings("unchecked") + private void installCustomActions() { + + ActionRegistry registry = getActionRegistry(); + + IExtensionRegistry reg = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = reg + .getExtensionPoint("de.bmotionstudio.gef.editor.installActions"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("action".equals(configurationElement.getName())) { + + try { + + IInstallActions installActionsClass = (IInstallActions) configurationElement + .createExecutableExtension("class"); + + installActionsClass.installActions(this); + HashMap<String, Action> actionMap = installActionsClass + .getActionMap(); + + for (Map.Entry<String, Action> entry : actionMap + .entrySet()) { + + registry.registerAction(entry.getValue()); + if (entry.getValue() instanceof SelectionAction) + getSelectionActions().add(entry.getKey()); + + } + + } catch (final CoreException e) { + e.printStackTrace(); + } + + } + + } + + } + + } + + protected Control getGraphicalControl() { + return rulerComp; + } + + protected void createGraphicalViewer(Composite parent) { + rulerComp = new RulerComposite(parent, SWT.NONE); + super.createGraphicalViewer(rulerComp); + rulerComp + .setGraphicalViewer((ScrollingGraphicalViewer) getGraphicalViewer()); + } + + /** + * @see org.eclipse.gef.ui.parts.GraphicalEditor#configureGraphicalViewer() + **/ + protected void configureGraphicalViewer() { + + double[] zoomLevels; + + super.configureGraphicalViewer(); + ScrollingGraphicalViewer viewer = (ScrollingGraphicalViewer) getGraphicalViewer(); + + viewer.setEditPartFactory(new AppEditPartFactory()); + + ScalableRootEditPart rootEditPart = new ScalableRootEditPart(); + viewer.setRootEditPart(rootEditPart); + + ZoomManager manager = rootEditPart.getZoomManager(); + getActionRegistry().registerAction(new ZoomInAction(manager)); + getActionRegistry().registerAction(new ZoomOutAction(manager)); + + zoomLevels = new double[] { 0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, + 4.0, 5.0, 10.0, 20.0 }; + manager.setZoomLevels(zoomLevels); + ArrayList<String> zoomContributions = new ArrayList<String>(); + zoomContributions.add(ZoomManager.FIT_ALL); + zoomContributions.add(ZoomManager.FIT_HEIGHT); + zoomContributions.add(ZoomManager.FIT_WIDTH); + manager.setZoomLevelContributions(zoomContributions); + + viewer.setProperty(MouseWheelHandler.KeyGenerator.getKey(SWT.NONE), + MouseWheelZoomHandler.SINGLETON); + + // viewer.setKeyHandler(keyHandler); + + viewer.setKeyHandler(new GraphicalViewerKeyHandler(viewer) + .setParent(getCommonKeyHandler())); + + loadProperties(); + + getActionRegistry().registerAction( + new ToggleRulerVisibilityAction(getGraphicalViewer())); + getActionRegistry().registerAction( + new ToggleSnapToGeometryAction(getGraphicalViewer())); + getActionRegistry().registerAction( + new ToggleGridAction(getGraphicalViewer())); + + ContextMenuProvider provider = new AppContextMenuProvider(viewer, + getActionRegistry()); + viewer.setContextMenu(provider); + + } + + protected void loadProperties() { + + // Ruler properties + BMotionRuler ruler = getVisualization() + .getRuler(PositionConstants.WEST); + RulerProvider provider = null; + if (ruler != null) { + provider = new BMotionRulerProvider(ruler); + } + getGraphicalViewer().setProperty(RulerProvider.PROPERTY_VERTICAL_RULER, + provider); + ruler = getVisualization().getRuler(PositionConstants.NORTH); + provider = null; + if (ruler != null) { + provider = new BMotionRulerProvider(ruler); + } + getGraphicalViewer().setProperty( + RulerProvider.PROPERTY_HORIZONTAL_RULER, provider); + getGraphicalViewer().setProperty( + RulerProvider.PROPERTY_RULER_VISIBILITY, + getVisualization().getRulerVisibility()); + getGraphicalViewer().setProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED, + getVisualization().isSnapToGeometryEnabled()); + getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_ENABLED, + getVisualization().isGridEnabled()); + getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_VISIBLE, + getVisualization().isGridEnabled()); + + getPalettePreferences().setPaletteState( + FlyoutPaletteComposite.STATE_PINNED_OPEN); + + } + + protected void saveProperties() { + getVisualization().setRulerVisibility( + ((Boolean) getGraphicalViewer().getProperty( + RulerProvider.PROPERTY_RULER_VISIBILITY)) + .booleanValue()); + getVisualization().setGridEnabled( + ((Boolean) getGraphicalViewer().getProperty( + SnapToGrid.PROPERTY_GRID_ENABLED)).booleanValue()); + getVisualization().setSnapToGeometry( + ((Boolean) getGraphicalViewer().getProperty( + SnapToGeometry.PROPERTY_SNAP_ENABLED)).booleanValue()); + } + + /** + * The <code>CommandStackListener</code> that listens for + * <code>CommandStack </code>changes. + */ + private CommandStackListener commandStackListener = new CommandStackListener() { + public void commandStackChanged(EventObject event) { + setDirty(getCommandStack().isDirty()); + } + }; + + /** + * Returns the <code>CommandStack</code> of this editor's + * <code>EditDomain</code>. + * + * @return the <code>CommandStack</code> + */ + @Override + public CommandStack getCommandStack() { + return getEditDomain().getCommandStack(); + } + + /** + * Returns the <code>CommandStackListener</code>. + * + * @return the <code>CommandStackListener</code> + */ + protected CommandStackListener getCommandStackListener() { + return commandStackListener; + } + + /** + * Returns the palette root. + */ + protected PaletteRoot getPaletteRoot() { + if (palette == null) { + palette = new EditorPaletteFactory().createPalette(visualization); + } + return palette; + } + + protected FigureCanvas getEditor() { + return (FigureCanvas) getGraphicalViewer().getControl(); + } + + @Override + public SelectionSynchronizer getSelectionSynchronizer() { + if (bmotionSelectionSynchronizer == null) + bmotionSelectionSynchronizer = new BMotionSelectionSynchronizer( + bmotionStudioEditor); + return bmotionSelectionSynchronizer; + } + + protected class BMotionOutlinePage extends ContentOutlinePage { + + private SashForm sash; + + private ScrollableThumbnail thumbnail; + private DisposeListener disposeListener; + + public BMotionOutlinePage() { + super(new TreeViewer()); + } + + public void init(IPageSite pageSite) { + super.init(pageSite); + IActionBars bars = pageSite.getActionBars(); + ActionRegistry ar = getActionRegistry(); + bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), + ar.getAction(ActionFactory.UNDO.getId())); + bars.setGlobalActionHandler(ActionFactory.REDO.getId(), + ar.getAction(ActionFactory.REDO.getId())); + bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), + ar.getAction(ActionFactory.DELETE.getId())); + bars.setGlobalActionHandler(ActionFactory.COPY.getId(), + ar.getAction(ActionFactory.COPY.getId())); + bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), + ar.getAction(ActionFactory.PASTE.getId())); + buildCustomActions(bars, ar); + bars.updateActionBars(); + } + + protected void configureOutlineViewer() { + getViewer().setEditDomain(getEditDomain()); + getViewer().setEditPartFactory(new AppTreeEditPartFactory()); + ContextMenuProvider provider = new AppContextMenuProvider( + getViewer(), getActionRegistry()); + getViewer().setContextMenu(provider); + getViewer().setKeyHandler(getCommonKeyHandler()); + } + + protected void initializeOutlineViewer() { + setContents(getVisualization()); + } + + public void setContents(Object contents) { + getViewer().setContents(contents); + } + + protected void hookOutlineViewer() { + getSelectionSynchronizer().addViewer(getViewer()); + } + + protected void unhookOutlineViewer() { + getSelectionSynchronizer().removeViewer(getViewer()); + if (getGraphicalViewer().getControl() != null + && !getGraphicalViewer().getControl().isDisposed()) + getGraphicalViewer().getControl().removeDisposeListener( + disposeListener); + } + + @Override + public void createControl(Composite parent) { + initializeOverview(parent); + getGraphicalViewer().getControl().addDisposeListener( + disposeListener); + configureOutlineViewer(); + hookOutlineViewer(); + initializeOutlineViewer(); + createMenu(); + } + + /** + * + */ + private void createMenu() { + + Action expandAllAction = new Action("Expand All") { + + @Override + public void run() { + for (TreeItem item : ((Tree) getViewer().getControl()) + .getItems()) { + item.setExpanded(true); + } + } + + }; + + Action collapseAllAction = new Action("Collapse All") { + + @Override + public void run() { + for (TreeItem item : ((Tree) getViewer().getControl()) + .getItems()) { + item.setExpanded(false); + } + } + + }; + // collapseAllAction + // .setImageDescriptor(ImageDescriptor + // .createFromImage(PlatformUI + // .getWorkbench() + // .getSharedImages() + // .getImage( + // ISharedImages.IMG_ELCL_COLLAPSEALL))); + + getSite().getActionBars().getMenuManager().add(expandAllAction); + getSite().getActionBars().getMenuManager().add(collapseAllAction); + + } + + protected void initializeOverview(Composite parent) { + sash = new SashForm(parent, SWT.VERTICAL); + + getViewer().createControl(sash); + + Canvas canvas = new Canvas(sash, SWT.BORDER); + canvas.setBackground(Display.getDefault().getSystemColor( + SWT.COLOR_WHITE)); + LightweightSystem lws = new LightweightSystem(canvas); + + thumbnail = new ScrollableThumbnail( + (Viewport) ((ScalableRootEditPart) getGraphicalViewer() + .getRootEditPart()).getFigure()); + thumbnail.setSource(((ScalableRootEditPart) getGraphicalViewer() + .getRootEditPart()) + .getLayer(LayerConstants.PRINTABLE_LAYERS)); + + lws.setContents(thumbnail); + + disposeListener = new DisposeListener() { + public void widgetDisposed(DisposeEvent e) { + if (thumbnail != null) { + thumbnail.deactivate(); + thumbnail = null; + } + } + }; + } + + public Control getControl() { + return sash; + } + + public void dispose() { + unhookOutlineViewer(); + super.dispose(); + } + + } + + private void buildCustomActions(IActionBars bars, ActionRegistry ar) { + + IExtensionRegistry reg = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = reg + .getExtensionPoint("de.bmotionstudio.gef.editor.installMenu"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("menu".equals(configurationElement.getName())) { + + try { + + IInstallMenu installMenuClass = (IInstallMenu) configurationElement + .createExecutableExtension("class"); + + installMenuClass.installBar(bars, getActionRegistry()); + + } catch (final CoreException e) { + e.printStackTrace(); + } + + } + + } + + } + + } + + public Visualization getVisualization() { + return visualization; + } + + public void setBMotionStudioEditor(BMotionStudioEditor bmotionStudioEditor) { + this.bmotionStudioEditor = bmotionStudioEditor; + } + + public BMotionStudioEditor getBMotionStudioEditor() { + return bmotionStudioEditor; + } + + public ScalableRootEditPart getRootEditPart() { + return (ScalableRootEditPart) getGraphicalViewer().getRootEditPart(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioImage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioImage.java index b3eaa999e181a45a3691bf94e1324dbf3d46834f..eabeb2389370646f2fdaf49da35fec14613e4c00 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioImage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BMotionStudioImage.java @@ -1,136 +1,136 @@ -/** - * (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.bmotionstudio.gef.editor; - -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.Platform; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.jface.resource.ImageRegistry; -import org.eclipse.swt.graphics.Image; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -public class BMotionStudioImage { - - private static ImageRegistry imageReg = new ImageRegistry(); - private static boolean isInit = false; - - public static final String IMG_LOGO_B = "logo_b"; - public static final String IMG_LOGO_BMOTION = "logo_bmotion"; - public static final String IMG_LOGO_BMOTION64 = "logo_bmotion64"; - - public static final String IMG_ICON_MOTION = "icon_motion"; - public static final String IMG_ICON_MOTION_WIZ = "icon_motion_wiz"; - - public static ImageDescriptor getImageDescriptor(final String path) { - return getImageDescriptor(BMotionEditorPlugin.PLUGIN_ID, path); - } - - public static ImageDescriptor getImageDescriptor(final String pluginID, - final String path) { - return AbstractUIPlugin.imageDescriptorFromPlugin(pluginID, path); - } - - public static void registerImage(final String key, final String path) { - ImageDescriptor desc = getImageDescriptor(path); - imageReg.put(key, desc); - } - - public static void registerImage(final String key, final String pluginID, - final String path) { - ImageDescriptor desc = getImageDescriptor(pluginID, path); - imageReg.put(key, desc); - } - - public static Image getImage(final String key) { - if (!isInit) - initializeImageRegistry(); - return imageReg.get(key); - } - - public static Image getBControlImage(final String bcontrolID) { - if (!isInit) - initializeImageRegistry(); - return getImage("icon_control_" + bcontrolID); - } - - private static void initializeImageRegistry() { - - registerImage(IMG_LOGO_B, "icons/logo_b.gif"); - registerImage(IMG_LOGO_BMOTION, "icons/logo_bmotion.png"); - registerImage(IMG_LOGO_BMOTION64, "icons/logo_bmotion_64.png"); - registerImage(IMG_ICON_MOTION, "icons/icon_motion.gif"); - registerImage(IMG_ICON_MOTION_WIZ, "icons/icon_motion_wiz.gif"); - - registerBControlImages(); - - final IExtensionRegistry reg = Platform.getExtensionRegistry(); - final IExtensionPoint extensionPoint = reg - .getExtensionPoint("de.bmotionstudio.gef.editor.registerImages"); - - for (final IExtension extension : extensionPoint.getExtensions()) { - for (final IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("registerImages".equals(configurationElement.getName())) { - - try { - - IBMotionStudioImageRegistry imageReg = (IBMotionStudioImageRegistry) configurationElement - .createExecutableExtension("class"); - - imageReg.registerImages(); - - } catch (CoreException e) { - e.printStackTrace(); - } - - } - - } - - } - - isInit = true; - - } - - private static void registerBControlImages() { - - final IExtensionRegistry registry = Platform.getExtensionRegistry(); - final IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.control"); - - for (final IExtension extension : extensionPoint.getExtensions()) { - - for (final IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("control".equals(configurationElement.getName())) { - - final String icon = configurationElement - .getAttribute("icon"); - final String ID = configurationElement.getAttribute("id"); - final String sourcePluginID = configurationElement - .getContributor().getName(); - - final String key = "icon_control_" + ID; - - registerImage(key, sourcePluginID, icon); - - } - - } - - } - - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.Platform; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.resource.ImageRegistry; +import org.eclipse.swt.graphics.Image; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +public class BMotionStudioImage { + + private static ImageRegistry imageReg = new ImageRegistry(); + private static boolean isInit = false; + + public static final String IMG_LOGO_B = "logo_b"; + public static final String IMG_LOGO_BMOTION = "logo_bmotion"; + public static final String IMG_LOGO_BMOTION64 = "logo_bmotion64"; + + public static final String IMG_ICON_MOTION = "icon_motion"; + public static final String IMG_ICON_MOTION_WIZ = "icon_motion_wiz"; + + public static ImageDescriptor getImageDescriptor(final String path) { + return getImageDescriptor(BMotionEditorPlugin.PLUGIN_ID, path); + } + + public static ImageDescriptor getImageDescriptor(final String pluginID, + final String path) { + return AbstractUIPlugin.imageDescriptorFromPlugin(pluginID, path); + } + + public static void registerImage(final String key, final String path) { + ImageDescriptor desc = getImageDescriptor(path); + imageReg.put(key, desc); + } + + public static void registerImage(final String key, final String pluginID, + final String path) { + ImageDescriptor desc = getImageDescriptor(pluginID, path); + imageReg.put(key, desc); + } + + public static Image getImage(final String key) { + if (!isInit) + initializeImageRegistry(); + return imageReg.get(key); + } + + public static Image getBControlImage(final String bcontrolID) { + if (!isInit) + initializeImageRegistry(); + return getImage("icon_control_" + bcontrolID); + } + + private static void initializeImageRegistry() { + + registerImage(IMG_LOGO_B, "icons/logo_b.gif"); + registerImage(IMG_LOGO_BMOTION, "icons/logo_bmotion.png"); + registerImage(IMG_LOGO_BMOTION64, "icons/logo_bmotion_64.png"); + registerImage(IMG_ICON_MOTION, "icons/icon_motion.gif"); + registerImage(IMG_ICON_MOTION_WIZ, "icons/icon_motion_wiz.gif"); + + registerBControlImages(); + + final IExtensionRegistry reg = Platform.getExtensionRegistry(); + final IExtensionPoint extensionPoint = reg + .getExtensionPoint("de.bmotionstudio.gef.editor.registerImages"); + + for (final IExtension extension : extensionPoint.getExtensions()) { + for (final IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("registerImages".equals(configurationElement.getName())) { + + try { + + IBMotionStudioImageRegistry imageReg = (IBMotionStudioImageRegistry) configurationElement + .createExecutableExtension("class"); + + imageReg.registerImages(); + + } catch (CoreException e) { + e.printStackTrace(); + } + + } + + } + + } + + isInit = true; + + } + + private static void registerBControlImages() { + + final IExtensionRegistry registry = Platform.getExtensionRegistry(); + final IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.control"); + + for (final IExtension extension : extensionPoint.getExtensions()) { + + for (final IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("control".equals(configurationElement.getName())) { + + final String icon = configurationElement + .getAttribute("icon"); + final String ID = configurationElement.getAttribute("id"); + final String sourcePluginID = configurationElement + .getContributor().getName(); + + final String key = "icon_control_" + ID; + + registerImage(key, sourcePluginID, icon); + + } + + } + + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BindingObject.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BindingObject.java index e4338e73da0878fe9fdf154b6386acdae9b90f15..657ea9a4224ff6e4e347bed1d73acf3e8cca06f6 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BindingObject.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/BindingObject.java @@ -1,64 +1,64 @@ -/** - * (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.bmotionstudio.gef.editor; - -import java.beans.PropertyChangeListener; -import java.beans.PropertyChangeSupport; - -/** - * - * @author Lukas Ladenberger - * - */ -public abstract class BindingObject implements Cloneable { - - private transient PropertyChangeSupport propertyChangeSupport; - - public void addPropertyChangeListener(PropertyChangeListener listener) { - getPropertyChangeSupport().addPropertyChangeListener(listener); - } - - public void addPropertyChangeListener(String propertyName, - PropertyChangeListener listener) { - getPropertyChangeSupport().addPropertyChangeListener(propertyName, - listener); - } - - public void removePropertyChangeListener(PropertyChangeListener listener) { - getPropertyChangeSupport().removePropertyChangeListener(listener); - } - - public void removePropertyChangeListener(String propertyName, - PropertyChangeListener listener) { - getPropertyChangeSupport().removePropertyChangeListener(propertyName, - listener); - } - - protected void firePropertyChange(String propertyName, Object oldValue, - Object newValue) { - getPropertyChangeSupport().firePropertyChange(propertyName, oldValue, - newValue); - } - - public void setPropertyChangeSupport( - PropertyChangeSupport propertyChangeSupport) { - this.propertyChangeSupport = propertyChangeSupport; - } - - public PropertyChangeSupport getPropertyChangeSupport() { - if (propertyChangeSupport == null) - propertyChangeSupport = new PropertyChangeSupport(this); - return propertyChangeSupport; - } - - public BindingObject clone() throws CloneNotSupportedException { - BindingObject clone = (BindingObject) super.clone(); - clone.setPropertyChangeSupport(null); - return clone; - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; + +/** + * + * @author Lukas Ladenberger + * + */ +public abstract class BindingObject implements Cloneable { + + private transient PropertyChangeSupport propertyChangeSupport; + + public void addPropertyChangeListener(PropertyChangeListener listener) { + getPropertyChangeSupport().addPropertyChangeListener(listener); + } + + public void addPropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + getPropertyChangeSupport().addPropertyChangeListener(propertyName, + listener); + } + + public void removePropertyChangeListener(PropertyChangeListener listener) { + getPropertyChangeSupport().removePropertyChangeListener(listener); + } + + public void removePropertyChangeListener(String propertyName, + PropertyChangeListener listener) { + getPropertyChangeSupport().removePropertyChangeListener(propertyName, + listener); + } + + protected void firePropertyChange(String propertyName, Object oldValue, + Object newValue) { + getPropertyChangeSupport().firePropertyChange(propertyName, oldValue, + newValue); + } + + public void setPropertyChangeSupport( + PropertyChangeSupport propertyChangeSupport) { + this.propertyChangeSupport = propertyChangeSupport; + } + + public PropertyChangeSupport getPropertyChangeSupport() { + if (propertyChangeSupport == null) + propertyChangeSupport = new PropertyChangeSupport(this); + return propertyChangeSupport; + } + + public BindingObject clone() throws CloneNotSupportedException { + BindingObject clone = (BindingObject) super.clone(); + clone.setPropertyChangeSupport(null); + return clone; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/EditorPaletteFactory.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/EditorPaletteFactory.java index 64af86839a8e7ca1c79fb9e7e5392b91bfbec180..82f237b384f0dba47687681aab2ce2496da7d255 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/EditorPaletteFactory.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/EditorPaletteFactory.java @@ -1,179 +1,179 @@ -/** - * (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.bmotionstudio.gef.editor; - -import java.util.HashMap; -import java.util.Map; - -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.Platform; -import org.eclipse.gef.palette.ConnectionCreationToolEntry; -import org.eclipse.gef.palette.MarqueeToolEntry; -import org.eclipse.gef.palette.PaletteContainer; -import org.eclipse.gef.palette.PaletteDrawer; -import org.eclipse.gef.palette.PaletteRoot; -import org.eclipse.gef.palette.PaletteToolbar; -import org.eclipse.gef.palette.PanningSelectionToolEntry; -import org.eclipse.gef.palette.ToolEntry; - -import de.bmotionstudio.gef.editor.model.BConnection; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class EditorPaletteFactory { - - private HashMap<String, PaletteDrawer> groupMap = new HashMap<String, PaletteDrawer>(); - - /** - * Creates the PaletteRoot and adds all palette elements. Use this factory - * method to create a new palette for your graphical editor. - * - * @param visualization - * - * @param editor - * - * @return a new PaletteRoot - */ - public PaletteRoot createPalette(Visualization visualization) { - PaletteRoot palette = new PaletteRoot(); - palette.add(createToolsGroup(palette, visualization)); - createControls(palette, visualization); - createFromExtension(palette, visualization); - return palette; - } - - private void createFromExtension(PaletteRoot palette, - Visualization visualization) { - IExtensionRegistry registry = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.paletteEntry"); - // Iterate over controls - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - if ("entry".equals(configurationElement.getName())) { - try { - IInstallPaletteEntry entry = (IInstallPaletteEntry) configurationElement - .createExecutableExtension("class"); - entry.installPaletteEntry(palette, groupMap); - } catch (CoreException e) { - e.printStackTrace(); - } - } - } - } - } - - private void createControls(PaletteRoot palette, Visualization visualization) { - - IExtensionRegistry registry = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.control"); - - // Iterate over groups - for (IExtension extension : extensionPoint.getExtensions()) { - - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("group".equals(configurationElement.getName())) { - - String groupID = configurationElement.getAttribute("id"); - String groupName = configurationElement - .getAttribute("name"); - - PaletteDrawer componentsDrawer = new PaletteDrawer( - groupName); - if (!groupMap.containsKey(groupID)) - groupMap.put(groupID, componentsDrawer); - - } - - } - - } - - // Iterate over controls - for (IExtension extension : extensionPoint.getExtensions()) { - - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("control".equals(configurationElement.getName())) { - - String groupID = configurationElement - .getAttribute("groupid"); - PaletteDrawer groupDrawer = groupMap.get(groupID); - - if (groupDrawer != null) { - - // boolean createDefaultToolEntry = true; - - try { - IBControlService service = (IBControlService) configurationElement - .createExecutableExtension("service"); - if (service.showInPalette()) { - ToolEntry toolEntry = service.createToolEntry( - visualization, configurationElement); - if (toolEntry != null) { - groupDrawer.add(toolEntry); - } - } - } catch (CoreException e) { - // I think we can ignore the exception since - // we create a default tool entry which is - // independent from the configuration - // element - } - - // if (createDefaultToolEntry) - // groupDrawer.add(createDefaultToolEntry(type, - // visualization, configurationElement)); - - } - - } - - } - - } - - for (Map.Entry<String, PaletteDrawer> entry : groupMap.entrySet()) { - if (entry.getValue().getChildren().size() > 0) - palette.add(entry.getValue()); - } - - } - - /** - * Create the "Tools" group. - * - * @param visualization - */ - private PaletteContainer createToolsGroup(PaletteRoot palette, - Visualization visualization) { - PaletteToolbar toolbar = new PaletteToolbar("Tools"); - // Add a selection tool to the group - ToolEntry tool = new PanningSelectionToolEntry(); - toolbar.add(tool); - palette.setDefaultEntry(tool); - // Add a marquee tool to the group - toolbar.add(new MarqueeToolEntry()); - // Add connector tool to the group - toolbar.add(new ConnectionCreationToolEntry("Connection", - "Universal Connector", new BControlCreationFactory( - BConnection.TYPE, visualization), BMotionStudioImage - .getImageDescriptor("icons/icon_connection16.gif"), - BMotionStudioImage - .getImageDescriptor("icons/icon_connection24.gif"))); - return toolbar; - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.Platform; +import org.eclipse.gef.palette.ConnectionCreationToolEntry; +import org.eclipse.gef.palette.MarqueeToolEntry; +import org.eclipse.gef.palette.PaletteContainer; +import org.eclipse.gef.palette.PaletteDrawer; +import org.eclipse.gef.palette.PaletteRoot; +import org.eclipse.gef.palette.PaletteToolbar; +import org.eclipse.gef.palette.PanningSelectionToolEntry; +import org.eclipse.gef.palette.ToolEntry; + +import de.bmotionstudio.gef.editor.model.BConnection; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class EditorPaletteFactory { + + private HashMap<String, PaletteDrawer> groupMap = new HashMap<String, PaletteDrawer>(); + + /** + * Creates the PaletteRoot and adds all palette elements. Use this factory + * method to create a new palette for your graphical editor. + * + * @param visualization + * + * @param editor + * + * @return a new PaletteRoot + */ + public PaletteRoot createPalette(Visualization visualization) { + PaletteRoot palette = new PaletteRoot(); + palette.add(createToolsGroup(palette, visualization)); + createControls(palette, visualization); + createFromExtension(palette, visualization); + return palette; + } + + private void createFromExtension(PaletteRoot palette, + Visualization visualization) { + IExtensionRegistry registry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.paletteEntry"); + // Iterate over controls + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + if ("entry".equals(configurationElement.getName())) { + try { + IInstallPaletteEntry entry = (IInstallPaletteEntry) configurationElement + .createExecutableExtension("class"); + entry.installPaletteEntry(palette, groupMap); + } catch (CoreException e) { + e.printStackTrace(); + } + } + } + } + } + + private void createControls(PaletteRoot palette, Visualization visualization) { + + IExtensionRegistry registry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.control"); + + // Iterate over groups + for (IExtension extension : extensionPoint.getExtensions()) { + + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("group".equals(configurationElement.getName())) { + + String groupID = configurationElement.getAttribute("id"); + String groupName = configurationElement + .getAttribute("name"); + + PaletteDrawer componentsDrawer = new PaletteDrawer( + groupName); + if (!groupMap.containsKey(groupID)) + groupMap.put(groupID, componentsDrawer); + + } + + } + + } + + // Iterate over controls + for (IExtension extension : extensionPoint.getExtensions()) { + + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("control".equals(configurationElement.getName())) { + + String groupID = configurationElement + .getAttribute("groupid"); + PaletteDrawer groupDrawer = groupMap.get(groupID); + + if (groupDrawer != null) { + + // boolean createDefaultToolEntry = true; + + try { + IBControlService service = (IBControlService) configurationElement + .createExecutableExtension("service"); + if (service.showInPalette()) { + ToolEntry toolEntry = service.createToolEntry( + visualization, configurationElement); + if (toolEntry != null) { + groupDrawer.add(toolEntry); + } + } + } catch (CoreException e) { + // I think we can ignore the exception since + // we create a default tool entry which is + // independent from the configuration + // element + } + + // if (createDefaultToolEntry) + // groupDrawer.add(createDefaultToolEntry(type, + // visualization, configurationElement)); + + } + + } + + } + + } + + for (Map.Entry<String, PaletteDrawer> entry : groupMap.entrySet()) { + if (entry.getValue().getChildren().size() > 0) + palette.add(entry.getValue()); + } + + } + + /** + * Create the "Tools" group. + * + * @param visualization + */ + private PaletteContainer createToolsGroup(PaletteRoot palette, + Visualization visualization) { + PaletteToolbar toolbar = new PaletteToolbar("Tools"); + // Add a selection tool to the group + ToolEntry tool = new PanningSelectionToolEntry(); + toolbar.add(tool); + palette.setDefaultEntry(tool); + // Add a marquee tool to the group + toolbar.add(new MarqueeToolEntry()); + // Add connector tool to the group + toolbar.add(new ConnectionCreationToolEntry("Connection", + "Universal Connector", new BControlCreationFactory( + BConnection.TYPE, visualization), BMotionStudioImage + .getImageDescriptor("icons/icon_connection16.gif"), + BMotionStudioImage + .getImageDescriptor("icons/icon_connection24.gif"))); + return toolbar; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallActions.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallActions.java index feb252464e08a8aa477585bf5566ac775067d677..d2c7ada34e81b60a5df819d79fe2c4769c468179 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallActions.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallActions.java @@ -1,31 +1,31 @@ -/** - * (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.bmotionstudio.gef.editor; - -import org.eclipse.ui.part.WorkbenchPart; - -import de.bmotionstudio.gef.editor.action.BringToBottomAction; -import de.bmotionstudio.gef.editor.action.BringToBottomStepAction; -import de.bmotionstudio.gef.editor.action.BringToTopAction; -import de.bmotionstudio.gef.editor.action.BringToTopStepAction; -import de.bmotionstudio.gef.editor.action.FitImageAction; -import de.bmotionstudio.gef.editor.action.RenameAction; - -public class InstallActions extends AbstractInstallActions implements - IInstallActions { - - public void installActions(final WorkbenchPart part) { - installAction(RenameAction.ID, new RenameAction(part)); - installAction(FitImageAction.ID, new FitImageAction(part)); - installAction(BringToTopAction.ID, new BringToTopAction(part)); - installAction(BringToBottomAction.ID, new BringToBottomAction(part)); - installAction(BringToTopStepAction.ID, new BringToTopStepAction(part)); - installAction(BringToBottomStepAction.ID, new BringToBottomStepAction( - part)); - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import org.eclipse.ui.part.WorkbenchPart; + +import de.bmotionstudio.gef.editor.action.BringToBottomAction; +import de.bmotionstudio.gef.editor.action.BringToBottomStepAction; +import de.bmotionstudio.gef.editor.action.BringToTopAction; +import de.bmotionstudio.gef.editor.action.BringToTopStepAction; +import de.bmotionstudio.gef.editor.action.FitImageAction; +import de.bmotionstudio.gef.editor.action.RenameAction; + +public class InstallActions extends AbstractInstallActions implements + IInstallActions { + + public void installActions(final WorkbenchPart part) { + installAction(RenameAction.ID, new RenameAction(part)); + installAction(FitImageAction.ID, new FitImageAction(part)); + installAction(BringToTopAction.ID, new BringToTopAction(part)); + installAction(BringToBottomAction.ID, new BringToBottomAction(part)); + installAction(BringToTopStepAction.ID, new BringToTopStepAction(part)); + installAction(BringToBottomStepAction.ID, new BringToBottomStepAction( + part)); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallMenu.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallMenu.java index b2c38c70835292ddb6582fb6a91301eac596504a..80e218fd68a77a67657c1fcbabd321d917b04de1 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallMenu.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/InstallMenu.java @@ -1,56 +1,56 @@ -/** - * (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.bmotionstudio.gef.editor; - -import org.eclipse.gef.ui.actions.ActionRegistry; -import org.eclipse.gef.ui.actions.GEFActionConstants; -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.action.IMenuManager; -import org.eclipse.jface.action.MenuManager; -import org.eclipse.ui.IActionBars; - -import de.bmotionstudio.gef.editor.action.BringToBottomAction; -import de.bmotionstudio.gef.editor.action.BringToBottomStepAction; -import de.bmotionstudio.gef.editor.action.BringToTopAction; -import de.bmotionstudio.gef.editor.action.BringToTopStepAction; -import de.bmotionstudio.gef.editor.action.FitImageAction; -import de.bmotionstudio.gef.editor.action.RenameAction; - -public class InstallMenu implements IInstallMenu { - - public void installMenu(IMenuManager menu, ActionRegistry regitry) { - - IAction action; - - action = regitry.getAction(FitImageAction.ID); - menu.appendToGroup(GEFActionConstants.GROUP_EDIT, action); - action = regitry.getAction(RenameAction.ID); - menu.appendToGroup(GEFActionConstants.GROUP_EDIT, action); - - // menu.appendToGroup(GEFActionConstants.GROUP_EDIT, new Separator( - // "de.bmotionstudio.gef.BringToGroup")); - - MenuManager adjustmentMenu = new MenuManager("Adjustment"); - menu.appendToGroup(GEFActionConstants.GROUP_EDIT, adjustmentMenu); - - action = regitry.getAction(BringToTopAction.ID); - adjustmentMenu.add(action); - action = regitry.getAction(BringToBottomAction.ID); - adjustmentMenu.add(action); - action = regitry.getAction(BringToTopStepAction.ID); - adjustmentMenu.add(action); - action = regitry.getAction(BringToBottomStepAction.ID); - adjustmentMenu.add(action); - - } - - public void installBar(IActionBars bars, ActionRegistry regitry) { - // bars.setGlobalActionHandler(ActionFactory.RENAME.getId(), regitry - // .getAction(ActionFactory.RENAME.getId())); - } - -} +/** + * (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.bmotionstudio.gef.editor; + +import org.eclipse.gef.ui.actions.ActionRegistry; +import org.eclipse.gef.ui.actions.GEFActionConstants; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.action.IMenuManager; +import org.eclipse.jface.action.MenuManager; +import org.eclipse.ui.IActionBars; + +import de.bmotionstudio.gef.editor.action.BringToBottomAction; +import de.bmotionstudio.gef.editor.action.BringToBottomStepAction; +import de.bmotionstudio.gef.editor.action.BringToTopAction; +import de.bmotionstudio.gef.editor.action.BringToTopStepAction; +import de.bmotionstudio.gef.editor.action.FitImageAction; +import de.bmotionstudio.gef.editor.action.RenameAction; + +public class InstallMenu implements IInstallMenu { + + public void installMenu(IMenuManager menu, ActionRegistry regitry) { + + IAction action; + + action = regitry.getAction(FitImageAction.ID); + menu.appendToGroup(GEFActionConstants.GROUP_EDIT, action); + action = regitry.getAction(RenameAction.ID); + menu.appendToGroup(GEFActionConstants.GROUP_EDIT, action); + + // menu.appendToGroup(GEFActionConstants.GROUP_EDIT, new Separator( + // "de.bmotionstudio.gef.BringToGroup")); + + MenuManager adjustmentMenu = new MenuManager("Adjustment"); + menu.appendToGroup(GEFActionConstants.GROUP_EDIT, adjustmentMenu); + + action = regitry.getAction(BringToTopAction.ID); + adjustmentMenu.add(action); + action = regitry.getAction(BringToBottomAction.ID); + adjustmentMenu.add(action); + action = regitry.getAction(BringToTopStepAction.ID); + adjustmentMenu.add(action); + action = regitry.getAction(BringToBottomStepAction.ID); + adjustmentMenu.add(action); + + } + + public void installBar(IActionBars bars, ActionRegistry regitry) { + // bars.setGlobalActionHandler(ActionFactory.RENAME.getId(), regitry + // .getAction(ActionFactory.RENAME.getId())); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionAbstractWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionAbstractWizardDialog.java similarity index 92% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionAbstractWizard.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionAbstractWizardDialog.java index 8286414959eceff4c0cd24db1347ba9cd6c5e9ef..d9a3d5c380584994b742f7faf36ad8d7b89d886a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionAbstractWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionAbstractWizardDialog.java @@ -27,7 +27,7 @@ import org.eclipse.ui.IWorkbenchPart; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.EditorImageRegistry; -public abstract class BMotionAbstractWizard extends WizardDialog { +public abstract class BMotionAbstractWizardDialog extends WizardDialog { public static final int DELETE = 3; @@ -35,7 +35,7 @@ public abstract class BMotionAbstractWizard extends WizardDialog { private String deleteToolTip; - public BMotionAbstractWizard(IWorkbenchPart workbenchPart, IWizard newWizard) { + public BMotionAbstractWizardDialog(IWorkbenchPart workbenchPart, IWizard newWizard) { super(workbenchPart.getSite().getShell(), newWizard); this.workbenchPart = workbenchPart; } diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionObserverWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionObserverWizardDialog.java similarity index 80% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionObserverWizard.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionObserverWizardDialog.java index 154c8f27cbc978d0249b1283cb28a9ff2e700d9e..46ff0b2aefbf331ebb500d982903448255c75270 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionObserverWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionObserverWizardDialog.java @@ -12,9 +12,9 @@ import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Display; import org.eclipse.ui.IWorkbenchPart; -public class BMotionObserverWizard extends BMotionAbstractWizard { +public class BMotionObserverWizardDialog extends BMotionAbstractWizardDialog { - public BMotionObserverWizard(IWorkbenchPart workbenchPart, IWizard newWizard) { + public BMotionObserverWizardDialog(IWorkbenchPart workbenchPart, IWizard newWizard) { super(workbenchPart, newWizard); setShellStyle(SWT.CLOSE); setDeleteToolTip("Delete Observer"); diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionSchedulerEventWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionSchedulerEventWizardDialog.java similarity index 81% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionSchedulerEventWizard.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionSchedulerEventWizardDialog.java index 4f2b28f2412d0f2ce6e4f69bb8b3426735d452ce..f14aa16a5b28e12a8e7b0601ef55e65850ec328c 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionSchedulerEventWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionSchedulerEventWizardDialog.java @@ -8,16 +8,18 @@ package de.bmotionstudio.gef.editor.action; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.wizard.IWizard; +import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Display; import org.eclipse.ui.IWorkbenchPart; import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; -public class BMotionSchedulerEventWizard extends BMotionAbstractWizard { +public class BMotionSchedulerEventWizardDialog extends BMotionAbstractWizardDialog { - public BMotionSchedulerEventWizard(IWorkbenchPart workbenchPart, + public BMotionSchedulerEventWizardDialog(IWorkbenchPart workbenchPart, IWizard newWizard) { super(workbenchPart, newWizard); + setShellStyle(SWT.CLOSE); setDeleteToolTip("Delete Event"); } diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverAddItemAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionWizardAddItemAction.java similarity index 84% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverAddItemAction.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionWizardAddItemAction.java index 3032d262182a434552c53ec56da03945ab2e0179..2f8b5d46dc22e42c7b94e193528b2ebfaabf22c4 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverAddItemAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionWizardAddItemAction.java @@ -4,7 +4,7 @@ * This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html) * */ -package de.bmotionstudio.gef.editor.observer.wizard; +package de.bmotionstudio.gef.editor.action; import org.eclipse.core.databinding.observable.list.WritableList; import org.eclipse.jface.action.Action; @@ -13,12 +13,12 @@ import org.eclipse.jface.viewers.TableViewer; import de.bmotionstudio.gef.editor.BMotionStudioImage; -public class WizardObserverAddItemAction extends Action { +public class BMotionWizardAddItemAction extends Action { private TableViewer viewer; private Class<?> itemClass; - public WizardObserverAddItemAction(TableViewer viewer, Class<?> itemClass) { + public BMotionWizardAddItemAction(TableViewer viewer, Class<?> itemClass) { this.viewer = viewer; this.itemClass = itemClass; setText("Add new item"); diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDeleteItemsAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionWizardDeleteItemsAction.java similarity index 84% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDeleteItemsAction.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionWizardDeleteItemsAction.java index f9b295f45726c41dff06010ba604f82177b3b836..1ad64e4046aec6232ca6f4a2c27fe400bc103345 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDeleteItemsAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BMotionWizardDeleteItemsAction.java @@ -4,7 +4,7 @@ * This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html) * */ -package de.bmotionstudio.gef.editor.observer.wizard; +package de.bmotionstudio.gef.editor.action; import java.util.Arrays; @@ -17,11 +17,11 @@ import org.eclipse.swt.widgets.Display; import de.bmotionstudio.gef.editor.BMotionStudioImage; -public class WizardObserverDeleteItemsAction extends Action { +public class BMotionWizardDeleteItemsAction extends Action { private TableViewer viewer; - public WizardObserverDeleteItemsAction(TableViewer viewer) { + public BMotionWizardDeleteItemsAction(TableViewer viewer) { this.viewer = viewer; setText("Delete selected items"); setImageDescriptor(BMotionStudioImage.getImageDescriptor( diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomAction.java index a194b704361fe7ee5e5d63f1ad3de237c467e43d..0a599f4e003db6814fba319f412f22720939b1d6 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomAction.java @@ -1,79 +1,79 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.command.BringToBottomCommand; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; -import de.bmotionstudio.gef.editor.part.VisualizationPart; - -public class BringToBottomAction extends SelectionAction { - - public final static String ID = "de.bmotionstudio.gef.editor.action.bringToBottom"; - - public BringToBottomAction(final IWorkbenchPart part) { - super(part); - setLazyEnablementCalculation(false); - } - - protected void init() { - setText("Bring to bottom"); - setToolTipText("Bring to bottom"); - setId(ID); - ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( - BMotionEditorPlugin.PLUGIN_ID, "icons/icon_bringtobottom.gif"); - if (icon != null) { - setImageDescriptor(icon); - } - setEnabled(false); - } - - @Override - protected boolean calculateEnabled() { - List<?> selectedObjects = getSelectedObjects(); - if (selectedObjects.size() == 1) { - if (selectedObjects.get(0) instanceof VisualizationPart) { - return false; - } - } - return true; - } - - public BringToBottomCommand createBringToBottomCommand( - List<BControl> modelList) { - BringToBottomCommand command = new BringToBottomCommand(); - command.setControlList(modelList); - return command; - } - - public void run() { - - List<BControl> modelList = new ArrayList<BControl>(); - - List<?> selectedObjects = getSelectedObjects(); - - for (Object obj : selectedObjects) { - if (obj instanceof AppAbstractEditPart) { - modelList - .add((BControl) ((AppAbstractEditPart) obj).getModel()); - } - } - - execute(createBringToBottomCommand(modelList)); - - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.command.BringToBottomCommand; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; +import de.bmotionstudio.gef.editor.part.VisualizationPart; + +public class BringToBottomAction extends SelectionAction { + + public final static String ID = "de.bmotionstudio.gef.editor.action.bringToBottom"; + + public BringToBottomAction(final IWorkbenchPart part) { + super(part); + setLazyEnablementCalculation(false); + } + + protected void init() { + setText("Bring to bottom"); + setToolTipText("Bring to bottom"); + setId(ID); + ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( + BMotionEditorPlugin.PLUGIN_ID, "icons/icon_bringtobottom.gif"); + if (icon != null) { + setImageDescriptor(icon); + } + setEnabled(false); + } + + @Override + protected boolean calculateEnabled() { + List<?> selectedObjects = getSelectedObjects(); + if (selectedObjects.size() == 1) { + if (selectedObjects.get(0) instanceof VisualizationPart) { + return false; + } + } + return true; + } + + public BringToBottomCommand createBringToBottomCommand( + List<BControl> modelList) { + BringToBottomCommand command = new BringToBottomCommand(); + command.setControlList(modelList); + return command; + } + + public void run() { + + List<BControl> modelList = new ArrayList<BControl>(); + + List<?> selectedObjects = getSelectedObjects(); + + for (Object obj : selectedObjects) { + if (obj instanceof AppAbstractEditPart) { + modelList + .add((BControl) ((AppAbstractEditPart) obj).getModel()); + } + } + + execute(createBringToBottomCommand(modelList)); + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomStepAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomStepAction.java index 07da88c2c8a32fbd45ad7273437fbbebbe4ca6ef..5ab0686daa9e7509083ae407650666b0fac39618 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomStepAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToBottomStepAction.java @@ -1,80 +1,80 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.command.BringToBottomStepCommand; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; -import de.bmotionstudio.gef.editor.part.VisualizationPart; - -public class BringToBottomStepAction extends SelectionAction { - - public final static String ID = "de.bmotionstudio.gef.editor.action.bringToBottomStep"; - - public BringToBottomStepAction(final IWorkbenchPart part) { - super(part); - setLazyEnablementCalculation(false); - } - - protected void init() { - setText("Bring to bottom (Step)"); - setToolTipText("Bring to bottom (Step)"); - setId(ID); - ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( - BMotionEditorPlugin.PLUGIN_ID, - "icons/icon_bringtobottomstep.gif"); - if (icon != null) { - setImageDescriptor(icon); - } - setEnabled(false); - } - - @Override - protected boolean calculateEnabled() { - List<?> selectedObjects = getSelectedObjects(); - if (selectedObjects.size() == 1) { - if (selectedObjects.get(0) instanceof VisualizationPart) { - return false; - } - } - return true; - } - - public BringToBottomStepCommand createBringToBottomStepCommand( - List<BControl> modelList) { - BringToBottomStepCommand command = new BringToBottomStepCommand(); - command.setControlList(modelList); - return command; - } - - public void run() { - - List<BControl> modelList = new ArrayList<BControl>(); - - List<?> selectedObjects = getSelectedObjects(); - - for (Object obj : selectedObjects) { - if (obj instanceof AppAbstractEditPart) { - modelList - .add((BControl) ((AppAbstractEditPart) obj).getModel()); - } - } - - execute(createBringToBottomStepCommand(modelList)); - - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.command.BringToBottomStepCommand; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; +import de.bmotionstudio.gef.editor.part.VisualizationPart; + +public class BringToBottomStepAction extends SelectionAction { + + public final static String ID = "de.bmotionstudio.gef.editor.action.bringToBottomStep"; + + public BringToBottomStepAction(final IWorkbenchPart part) { + super(part); + setLazyEnablementCalculation(false); + } + + protected void init() { + setText("Bring to bottom (Step)"); + setToolTipText("Bring to bottom (Step)"); + setId(ID); + ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( + BMotionEditorPlugin.PLUGIN_ID, + "icons/icon_bringtobottomstep.gif"); + if (icon != null) { + setImageDescriptor(icon); + } + setEnabled(false); + } + + @Override + protected boolean calculateEnabled() { + List<?> selectedObjects = getSelectedObjects(); + if (selectedObjects.size() == 1) { + if (selectedObjects.get(0) instanceof VisualizationPart) { + return false; + } + } + return true; + } + + public BringToBottomStepCommand createBringToBottomStepCommand( + List<BControl> modelList) { + BringToBottomStepCommand command = new BringToBottomStepCommand(); + command.setControlList(modelList); + return command; + } + + public void run() { + + List<BControl> modelList = new ArrayList<BControl>(); + + List<?> selectedObjects = getSelectedObjects(); + + for (Object obj : selectedObjects) { + if (obj instanceof AppAbstractEditPart) { + modelList + .add((BControl) ((AppAbstractEditPart) obj).getModel()); + } + } + + execute(createBringToBottomStepCommand(modelList)); + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopAction.java index 002d611a260f932bc22897493a7170681bdcf7b3..0789ad7329d4d4d50343a28f13bff3c397fe243d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopAction.java @@ -1,73 +1,73 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.command.BringToTopCommand; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; -import de.bmotionstudio.gef.editor.part.VisualizationPart; - -public class BringToTopAction extends SelectionAction { - - public final static String ID = "de.bmotionstudio.gef.editor.action.bringToTop"; - - public BringToTopAction(final IWorkbenchPart part) { - super(part); - setLazyEnablementCalculation(false); - } - - protected void init() { - setText("Bring to top"); - setToolTipText("Bring to top"); - setId(ID); - ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( - BMotionEditorPlugin.PLUGIN_ID, "icons/icon_bringtotop.gif"); - if (icon != null) { - setImageDescriptor(icon); - } - setEnabled(false); - } - - @Override - protected boolean calculateEnabled() { - List<?> selectedObjects = getSelectedObjects(); - if (selectedObjects.size() == 1) { - if (selectedObjects.get(0) instanceof VisualizationPart) { - return false; - } - } - return true; - } - - public BringToTopCommand createBringToTopCommand(List<BControl> controlList) { - BringToTopCommand command = new BringToTopCommand(); - command.setControlList(controlList); - return command; - } - - public void run() { - List<BControl> controlList = new ArrayList<BControl>(); - List<?> selectedObjects = getSelectedObjects(); - for (Object obj : selectedObjects) { - if (obj instanceof AppAbstractEditPart) { - controlList.add((BControl) ((AppAbstractEditPart) obj) - .getModel()); - } - } - execute(createBringToTopCommand(controlList)); - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.command.BringToTopCommand; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; +import de.bmotionstudio.gef.editor.part.VisualizationPart; + +public class BringToTopAction extends SelectionAction { + + public final static String ID = "de.bmotionstudio.gef.editor.action.bringToTop"; + + public BringToTopAction(final IWorkbenchPart part) { + super(part); + setLazyEnablementCalculation(false); + } + + protected void init() { + setText("Bring to top"); + setToolTipText("Bring to top"); + setId(ID); + ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( + BMotionEditorPlugin.PLUGIN_ID, "icons/icon_bringtotop.gif"); + if (icon != null) { + setImageDescriptor(icon); + } + setEnabled(false); + } + + @Override + protected boolean calculateEnabled() { + List<?> selectedObjects = getSelectedObjects(); + if (selectedObjects.size() == 1) { + if (selectedObjects.get(0) instanceof VisualizationPart) { + return false; + } + } + return true; + } + + public BringToTopCommand createBringToTopCommand(List<BControl> controlList) { + BringToTopCommand command = new BringToTopCommand(); + command.setControlList(controlList); + return command; + } + + public void run() { + List<BControl> controlList = new ArrayList<BControl>(); + List<?> selectedObjects = getSelectedObjects(); + for (Object obj : selectedObjects) { + if (obj instanceof AppAbstractEditPart) { + controlList.add((BControl) ((AppAbstractEditPart) obj) + .getModel()); + } + } + execute(createBringToTopCommand(controlList)); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopStepAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopStepAction.java index 7b1c8e97c08c96a1abdec0970cbe27b5546adbfc..2e0e89c5d76013b7fc913b1ed8b280512cad01b8 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopStepAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/BringToTopStepAction.java @@ -1,79 +1,79 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.command.BringToTopStepCommand; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; -import de.bmotionstudio.gef.editor.part.VisualizationPart; - -public class BringToTopStepAction extends SelectionAction { - - public final static String ID = "de.bmotionstudio.gef.editor.action.bringToTopStep"; - - public BringToTopStepAction(final IWorkbenchPart part) { - super(part); - setLazyEnablementCalculation(false); - } - - protected void init() { - setText("Bring to top (Step)"); - setToolTipText("Bring to top (Step)"); - setId(ID); - ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( - BMotionEditorPlugin.PLUGIN_ID, "icons/icon_bringtotopstep.gif"); - if (icon != null) { - setImageDescriptor(icon); - } - setEnabled(false); - } - - @Override - protected boolean calculateEnabled() { - List<?> selectedObjects = getSelectedObjects(); - if (selectedObjects.size() == 1) { - if (selectedObjects.get(0) instanceof VisualizationPart) { - return false; - } - } - return true; - } - - public BringToTopStepCommand createBringToTopStepCommand( - List<BControl> modelList) { - BringToTopStepCommand command = new BringToTopStepCommand(); - command.setControlList(modelList); - return command; - } - - public void run() { - - List<BControl> modelList = new ArrayList<BControl>(); - - List<?> selectedObjects = getSelectedObjects(); - - for (Object obj : selectedObjects) { - if (obj instanceof AppAbstractEditPart) { - modelList - .add((BControl) ((AppAbstractEditPart) obj).getModel()); - } - } - - execute(createBringToTopStepCommand(modelList)); - - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.command.BringToTopStepCommand; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; +import de.bmotionstudio.gef.editor.part.VisualizationPart; + +public class BringToTopStepAction extends SelectionAction { + + public final static String ID = "de.bmotionstudio.gef.editor.action.bringToTopStep"; + + public BringToTopStepAction(final IWorkbenchPart part) { + super(part); + setLazyEnablementCalculation(false); + } + + protected void init() { + setText("Bring to top (Step)"); + setToolTipText("Bring to top (Step)"); + setId(ID); + ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( + BMotionEditorPlugin.PLUGIN_ID, "icons/icon_bringtotopstep.gif"); + if (icon != null) { + setImageDescriptor(icon); + } + setEnabled(false); + } + + @Override + protected boolean calculateEnabled() { + List<?> selectedObjects = getSelectedObjects(); + if (selectedObjects.size() == 1) { + if (selectedObjects.get(0) instanceof VisualizationPart) { + return false; + } + } + return true; + } + + public BringToTopStepCommand createBringToTopStepCommand( + List<BControl> modelList) { + BringToTopStepCommand command = new BringToTopStepCommand(); + command.setControlList(modelList); + return command; + } + + public void run() { + + List<BControl> modelList = new ArrayList<BControl>(); + + List<?> selectedObjects = getSelectedObjects(); + + for (Object obj : selectedObjects) { + if (obj instanceof AppAbstractEditPart) { + modelList + .add((BControl) ((AppAbstractEditPart) obj).getModel()); + } + } + + execute(createBringToTopStepCommand(modelList)); + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/CopyAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/CopyAction.java index 0e0984a6654e422c6b5fadc8c42d80b1f6644799..7f59b18c7d63d10518003dbcc5c57c5301f3da5a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/CopyAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/CopyAction.java @@ -1,84 +1,84 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.util.Iterator; -import java.util.List; - -import org.eclipse.gef.EditPart; -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.ui.ISharedImages; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.PlatformUI; -import org.eclipse.ui.actions.ActionFactory; - -import de.bmotionstudio.gef.editor.command.CopyCommand; -import de.bmotionstudio.gef.editor.model.BControl; - -public class CopyAction extends SelectionAction { - - public CopyAction(IWorkbenchPart part) { - super(part); - // force calculateEnabled() to be called in every context - setLazyEnablementCalculation(true); - } - - @Override - protected void init() { - super.init(); - ISharedImages sharedImages = PlatformUI.getWorkbench() - .getSharedImages(); - setText("Copy"); - setId(ActionFactory.COPY.getId()); - setHoverImageDescriptor(sharedImages - .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); - setImageDescriptor(sharedImages - .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); - setDisabledImageDescriptor(sharedImages - .getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED)); - setEnabled(false); - } - - private Command createCopyCommand(List<Object> selectedObjects) { - if (selectedObjects == null || selectedObjects.isEmpty()) - return null; - CopyCommand cmd = new CopyCommand(); - Iterator<Object> it = selectedObjects.iterator(); - while (it.hasNext()) { - Object nextElement = it.next(); - if (nextElement instanceof EditPart) { - EditPart ep = (EditPart) nextElement; - BControl node = (BControl) ep.getModel(); - if (!cmd.isCopyableControl(node)) - return null; - cmd.addElement(node); - } - - } - return cmd; - } - - @SuppressWarnings("unchecked") - @Override - protected boolean calculateEnabled() { - Command cmd = createCopyCommand(getSelectedObjects()); - if (cmd == null) - return false; - return cmd.canExecute(); - } - - @SuppressWarnings("unchecked") - @Override - public void run() { - Command cmd = createCopyCommand(getSelectedObjects()); - if (cmd != null && cmd.canExecute()) { - cmd.execute(); - } - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.util.Iterator; +import java.util.List; + +import org.eclipse.gef.EditPart; +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.actions.ActionFactory; + +import de.bmotionstudio.gef.editor.command.CopyCommand; +import de.bmotionstudio.gef.editor.model.BControl; + +public class CopyAction extends SelectionAction { + + public CopyAction(IWorkbenchPart part) { + super(part); + // force calculateEnabled() to be called in every context + setLazyEnablementCalculation(true); + } + + @Override + protected void init() { + super.init(); + ISharedImages sharedImages = PlatformUI.getWorkbench() + .getSharedImages(); + setText("Copy"); + setId(ActionFactory.COPY.getId()); + setHoverImageDescriptor(sharedImages + .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); + setImageDescriptor(sharedImages + .getImageDescriptor(ISharedImages.IMG_TOOL_COPY)); + setDisabledImageDescriptor(sharedImages + .getImageDescriptor(ISharedImages.IMG_TOOL_COPY_DISABLED)); + setEnabled(false); + } + + private Command createCopyCommand(List<Object> selectedObjects) { + if (selectedObjects == null || selectedObjects.isEmpty()) + return null; + CopyCommand cmd = new CopyCommand(); + Iterator<Object> it = selectedObjects.iterator(); + while (it.hasNext()) { + Object nextElement = it.next(); + if (nextElement instanceof EditPart) { + EditPart ep = (EditPart) nextElement; + BControl node = (BControl) ep.getModel(); + if (!cmd.isCopyableControl(node)) + return null; + cmd.addElement(node); + } + + } + return cmd; + } + + @SuppressWarnings("unchecked") + @Override + protected boolean calculateEnabled() { + Command cmd = createCopyCommand(getSelectedObjects()); + if (cmd == null) + return false; + return cmd.canExecute(); + } + + @SuppressWarnings("unchecked") + @Override + public void run() { + Command cmd = createCopyCommand(getSelectedObjects()); + if (cmd != null && cmd.canExecute()) { + cmd.execute(); + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/FitImageAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/FitImageAction.java index ec7bd7f0c8cac4d6aa79b94fde6f690424e1b7f6..c8e06a550d8a87acc93298e9e087fed126fafb7f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/FitImageAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/FitImageAction.java @@ -1,144 +1,144 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.io.File; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.eclipse.core.resources.IFile; -import org.eclipse.gef.EditPart; -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.Rectangle; -import org.eclipse.swt.widgets.Display; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.command.FitImageCommand; -import de.bmotionstudio.gef.editor.model.BControl; - -public class FitImageAction extends SelectionAction { - - public final static String ID = "de.bmotionstudio.gef.editor.action.fitImage"; - - public FitImageAction(final IWorkbenchPart part) { - super(part); - setLazyEnablementCalculation(false); - } - - protected void init() { - setText("Fit size to image"); - setToolTipText("Fit size to image"); - setId(ID); - ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( - BMotionEditorPlugin.PLUGIN_ID, "icons/icon_fitimage.png"); - if (icon != null) { - setImageDescriptor(icon); - } - setEnabled(false); - } - - @Override - protected boolean calculateEnabled() { - List<?> selectedObjects = getSelectedObjects(); - for (Object obj : selectedObjects) { - if (obj instanceof EditPart) { - EditPart part = (EditPart) obj; - BControl bcontrol = (BControl) part.getModel(); - if (bcontrol - .getAttributeValue(AttributeConstants.ATTRIBUTE_IMAGE) != null) { - return true; - } - } - } - return false; - } - - public FitImageCommand createFitImageCommand(List<BControl> modelList, - Map<BControl, org.eclipse.draw2d.geometry.Rectangle> newSizeMap) { - FitImageCommand command = new FitImageCommand(); - command.setModelList(modelList); - command.setNewSizeMap(newSizeMap); - return command; - } - - public void run() { - - List<BControl> modelList = new ArrayList<BControl>(); - Map<BControl, org.eclipse.draw2d.geometry.Rectangle> newSizeMap = new HashMap<BControl, org.eclipse.draw2d.geometry.Rectangle>(); - - List<?> selectedObjects = getSelectedObjects(); - - for (Object obj : selectedObjects) { - - if (obj instanceof EditPart) { - - EditPart part = (EditPart) obj; - BControl control = (BControl) part.getModel(); - - Object imgAttribute = control - .getAttributeValue(AttributeConstants.ATTRIBUTE_IMAGE); - - if (imgAttribute != null) { - - String imagePath = control.getAttributeValue( - AttributeConstants.ATTRIBUTE_IMAGE).toString(); - - Rectangle imageBounds = null; - Image img = null; - - IFile pFile = control.getVisualization().getProjectFile(); - - if (pFile != null) { - final String myPath = (pFile.getProject().getLocation() - + "/images/" + imagePath).replace("file:", ""); - if (new File(myPath).exists() && imagePath.length() > 0) { - img = new Image(Display.getCurrent(), myPath); - imageBounds = img.getBounds(); - } - } - - if (imageBounds != null) { - - modelList.add(control); - newSizeMap - .put(control, - new org.eclipse.draw2d.geometry.Rectangle( - Integer.valueOf(control - .getAttributeValue( - AttributeConstants.ATTRIBUTE_X) - .toString()), - Integer.valueOf(control - .getAttributeValue( - AttributeConstants.ATTRIBUTE_Y) - .toString()), - imageBounds.width, - imageBounds.height)); - - } - - if (img != null) { - img.dispose(); - } - - } - - } - - } - - execute(createFitImageCommand(modelList, newSizeMap)); - - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.io.File; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.eclipse.core.resources.IFile; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.command.FitImageCommand; +import de.bmotionstudio.gef.editor.model.BControl; + +public class FitImageAction extends SelectionAction { + + public final static String ID = "de.bmotionstudio.gef.editor.action.fitImage"; + + public FitImageAction(final IWorkbenchPart part) { + super(part); + setLazyEnablementCalculation(false); + } + + protected void init() { + setText("Fit size to image"); + setToolTipText("Fit size to image"); + setId(ID); + ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( + BMotionEditorPlugin.PLUGIN_ID, "icons/icon_fitimage.png"); + if (icon != null) { + setImageDescriptor(icon); + } + setEnabled(false); + } + + @Override + protected boolean calculateEnabled() { + List<?> selectedObjects = getSelectedObjects(); + for (Object obj : selectedObjects) { + if (obj instanceof EditPart) { + EditPart part = (EditPart) obj; + BControl bcontrol = (BControl) part.getModel(); + if (bcontrol + .getAttributeValue(AttributeConstants.ATTRIBUTE_IMAGE) != null) { + return true; + } + } + } + return false; + } + + public FitImageCommand createFitImageCommand(List<BControl> modelList, + Map<BControl, org.eclipse.draw2d.geometry.Rectangle> newSizeMap) { + FitImageCommand command = new FitImageCommand(); + command.setModelList(modelList); + command.setNewSizeMap(newSizeMap); + return command; + } + + public void run() { + + List<BControl> modelList = new ArrayList<BControl>(); + Map<BControl, org.eclipse.draw2d.geometry.Rectangle> newSizeMap = new HashMap<BControl, org.eclipse.draw2d.geometry.Rectangle>(); + + List<?> selectedObjects = getSelectedObjects(); + + for (Object obj : selectedObjects) { + + if (obj instanceof EditPart) { + + EditPart part = (EditPart) obj; + BControl control = (BControl) part.getModel(); + + Object imgAttribute = control + .getAttributeValue(AttributeConstants.ATTRIBUTE_IMAGE); + + if (imgAttribute != null) { + + String imagePath = control.getAttributeValue( + AttributeConstants.ATTRIBUTE_IMAGE).toString(); + + Rectangle imageBounds = null; + Image img = null; + + IFile pFile = control.getVisualization().getProjectFile(); + + if (pFile != null) { + final String myPath = (pFile.getProject().getLocation() + + "/images/" + imagePath).replace("file:", ""); + if (new File(myPath).exists() && imagePath.length() > 0) { + img = new Image(Display.getCurrent(), myPath); + imageBounds = img.getBounds(); + } + } + + if (imageBounds != null) { + + modelList.add(control); + newSizeMap + .put(control, + new org.eclipse.draw2d.geometry.Rectangle( + Integer.valueOf(control + .getAttributeValue( + AttributeConstants.ATTRIBUTE_X) + .toString()), + Integer.valueOf(control + .getAttributeValue( + AttributeConstants.ATTRIBUTE_Y) + .toString()), + imageBounds.width, + imageBounds.height)); + + } + + if (img != null) { + img.dispose(); + } + + } + + } + + } + + execute(createFitImageCommand(modelList, newSizeMap)); + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/ObserverAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/OpenObserverAction.java similarity index 90% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/ObserverAction.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/OpenObserverAction.java index 60d41ba1c327d655b01e28c2f6a92ed27d0a47d1..f63e35f8a0cc0a6d2ef637b27692362e2527d7f5 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/ObserverAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/OpenObserverAction.java @@ -23,14 +23,14 @@ import de.bmotionstudio.gef.editor.observer.Observer; import de.bmotionstudio.gef.editor.observer.ObserverWizard; import de.prob.logging.Logger; -public class ObserverAction extends SelectionAction { +public class OpenObserverAction extends SelectionAction { private String className; private Observer clonedObserver; private Observer newObserver; private BControl actionControl; - public ObserverAction(IWorkbenchPart part) { + public OpenObserverAction(IWorkbenchPart part) { super(part); setLazyEnablementCalculation(true); } @@ -80,7 +80,7 @@ public class ObserverAction extends SelectionAction { if (wizard != null) { - BMotionObserverWizard dialog = new BMotionObserverWizard( + BMotionObserverWizardDialog dialog = new BMotionObserverWizardDialog( getWorkbenchPart(), wizard); dialog.create(); dialog.getShell().setSize(wizard.getSize()); @@ -121,7 +121,7 @@ public class ObserverAction extends SelectionAction { if (clonedObserver != null) actionControl.addObserver(clonedObserver); - } else if (status == BMotionObserverWizard.DELETE) { + } else if (status == BMotionObserverWizardDialog.DELETE) { RemoveObserverAction action = new RemoveObserverAction( getWorkbenchPart()); action.setControl(getControl()); diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/SchedulerEventAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/OpenSchedulerEventAction.java similarity index 92% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/SchedulerEventAction.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/OpenSchedulerEventAction.java index eebbb8f3405ef42d1fa48bfbbcc62a4e6f9372ed..dff15928f5b8e190611a5eaba4c8f43eff2ef959 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/SchedulerEventAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/OpenSchedulerEventAction.java @@ -23,13 +23,13 @@ import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; import de.prob.logging.Logger; -public class SchedulerEventAction extends SelectionAction { +public class OpenSchedulerEventAction extends SelectionAction { private String className; private String eventID; private SchedulerEvent clonedSchedulerEvent; - public SchedulerEventAction(IWorkbenchPart part) { + public OpenSchedulerEventAction(IWorkbenchPart part) { super(part); setLazyEnablementCalculation(true); } @@ -79,7 +79,7 @@ public class SchedulerEventAction extends SelectionAction { if (wizard != null) { - BMotionSchedulerEventWizard dialog = new BMotionSchedulerEventWizard( + BMotionSchedulerEventWizardDialog dialog = new BMotionSchedulerEventWizardDialog( getWorkbenchPart(), wizard); dialog.create(); dialog.getShell().setSize(wizard.getSize()); diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/PasteAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/PasteAction.java index bebe030a39054980809c4ab90abb7bfb07a45e3a..b534b8c2468facb8804e5f3ea4b21d63c83bb006 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/PasteAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/PasteAction.java @@ -1,58 +1,58 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.ui.ISharedImages; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.PlatformUI; -import org.eclipse.ui.actions.ActionFactory; - -import de.bmotionstudio.gef.editor.command.PasteCommand; - -public class PasteAction extends SelectionAction { - - public PasteAction(IWorkbenchPart part) { - super(part); - // force calculateEnabled() to be called in every context - setLazyEnablementCalculation(true); - } - - protected void init() { - super.init(); - ISharedImages sharedImages = PlatformUI.getWorkbench() - .getSharedImages(); - setText("Paste"); - setId(ActionFactory.PASTE.getId()); - setHoverImageDescriptor(sharedImages - .getImageDescriptor(ISharedImages.IMG_TOOL_PASTE)); - setImageDescriptor(sharedImages - .getImageDescriptor(ISharedImages.IMG_TOOL_PASTE)); - setDisabledImageDescriptor(sharedImages - .getImageDescriptor(ISharedImages.IMG_TOOL_PASTE_DISABLED)); - setEnabled(false); - } - - private PasteCommand createPasteCommand() { - return new PasteCommand(); - } - - @Override - protected boolean calculateEnabled() { - Command command = createPasteCommand(); - return command != null && command.canExecute(); - } - - @Override - public void run() { - PasteCommand command = createPasteCommand(); - if (command != null && command.canExecute()) - execute(command); - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.ui.ISharedImages; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.actions.ActionFactory; + +import de.bmotionstudio.gef.editor.command.PasteCommand; + +public class PasteAction extends SelectionAction { + + public PasteAction(IWorkbenchPart part) { + super(part); + // force calculateEnabled() to be called in every context + setLazyEnablementCalculation(true); + } + + protected void init() { + super.init(); + ISharedImages sharedImages = PlatformUI.getWorkbench() + .getSharedImages(); + setText("Paste"); + setId(ActionFactory.PASTE.getId()); + setHoverImageDescriptor(sharedImages + .getImageDescriptor(ISharedImages.IMG_TOOL_PASTE)); + setImageDescriptor(sharedImages + .getImageDescriptor(ISharedImages.IMG_TOOL_PASTE)); + setDisabledImageDescriptor(sharedImages + .getImageDescriptor(ISharedImages.IMG_TOOL_PASTE_DISABLED)); + setEnabled(false); + } + + private PasteCommand createPasteCommand() { + return new PasteCommand(); + } + + @Override + protected boolean calculateEnabled() { + Command command = createPasteCommand(); + return command != null && command.canExecute(); + } + + @Override + public void run() { + PasteCommand command = createPasteCommand(); + if (command != null && command.canExecute()) + execute(command); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/RenameAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/RenameAction.java index ab551e14c0e97659ed8bbcbcfcee88c2b44872e8..9e3529477541ca7c0ad0fa5a963d155c71d2ebc4 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/RenameAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/action/RenameAction.java @@ -1,103 +1,103 @@ -/** - * (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.bmotionstudio.gef.editor.action; - -import java.util.HashMap; -import java.util.List; - -import org.eclipse.gef.EditPart; -import org.eclipse.gef.Request; -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.ui.actions.SelectionAction; -import org.eclipse.jface.resource.ImageDescriptor; -import org.eclipse.jface.wizard.WizardDialog; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.actions.ActionFactory; -import org.eclipse.ui.plugin.AbstractUIPlugin; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.internal.RenameWizard; -import de.bmotionstudio.gef.editor.model.BControl; - -public class RenameAction extends SelectionAction { - - public final static String ID = ActionFactory.RENAME.getId(); - - public RenameAction(final IWorkbenchPart part) { - super(part); - setLazyEnablementCalculation(false); - } - - protected void init() { - setText("Rename..."); - setToolTipText("Rename"); - setId(ID); - ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( - BMotionEditorPlugin.PLUGIN_ID, "icons/icon_rename.png"); - if (icon != null) { - setImageDescriptor(icon); - } - setEnabled(false); - } - - @Override - protected boolean calculateEnabled() { - Command cmd = createRenameCommand(""); - if (cmd == null) { - return false; - } - return true; - } - - public Command createRenameCommand(final String name) { - Request renameReq = new Request("rename"); - - HashMap<String, String> reqData = new HashMap<String, String>(); - reqData.put("newName", name); - renameReq.setExtendedData(reqData); - - if (getSelectedObjects().size() > 0) { - if (getSelectedObjects().get(0) instanceof EditPart) { - EditPart object = (EditPart) getSelectedObjects().get(0); - Command cmd = object.getCommand(renameReq); - return cmd; - } - } - - return null; - } - - public void run() { - BControl bcontrol = getSelectedBControl(); - RenameWizard wizard = new RenameWizard(bcontrol.getAttributeValue( - AttributeConstants.ATTRIBUTE_TEXT).toString()); - WizardDialog dialog = new WizardDialog(getWorkbenchPart().getSite() - .getShell(), wizard); - dialog.create(); - dialog.getShell().setSize(400, 315); - dialog.getShell().setText("BMotion Studio Rename Wizard"); - - if (dialog.open() == WizardDialog.OK) { - String name = wizard.getRenameValue(); - execute(createRenameCommand(name)); - } - } - - private BControl getSelectedBControl() { - List<?> objects = getSelectedObjects(); - if (objects.isEmpty()) { - return null; - } - if (!(objects.get(0) instanceof EditPart)) { - return null; - } - EditPart part = (EditPart) objects.get(0); - return (BControl) part.getModel(); - } - -} +/** + * (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.bmotionstudio.gef.editor.action; + +import java.util.HashMap; +import java.util.List; + +import org.eclipse.gef.EditPart; +import org.eclipse.gef.Request; +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.ui.actions.SelectionAction; +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.wizard.WizardDialog; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.actions.ActionFactory; +import org.eclipse.ui.plugin.AbstractUIPlugin; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.internal.RenameWizard; +import de.bmotionstudio.gef.editor.model.BControl; + +public class RenameAction extends SelectionAction { + + public final static String ID = ActionFactory.RENAME.getId(); + + public RenameAction(final IWorkbenchPart part) { + super(part); + setLazyEnablementCalculation(false); + } + + protected void init() { + setText("Rename..."); + setToolTipText("Rename"); + setId(ID); + ImageDescriptor icon = AbstractUIPlugin.imageDescriptorFromPlugin( + BMotionEditorPlugin.PLUGIN_ID, "icons/icon_rename.png"); + if (icon != null) { + setImageDescriptor(icon); + } + setEnabled(false); + } + + @Override + protected boolean calculateEnabled() { + Command cmd = createRenameCommand(""); + if (cmd == null) { + return false; + } + return true; + } + + public Command createRenameCommand(final String name) { + Request renameReq = new Request("rename"); + + HashMap<String, String> reqData = new HashMap<String, String>(); + reqData.put("newName", name); + renameReq.setExtendedData(reqData); + + if (getSelectedObjects().size() > 0) { + if (getSelectedObjects().get(0) instanceof EditPart) { + EditPart object = (EditPart) getSelectedObjects().get(0); + Command cmd = object.getCommand(renameReq); + return cmd; + } + } + + return null; + } + + public void run() { + BControl bcontrol = getSelectedBControl(); + RenameWizard wizard = new RenameWizard(bcontrol.getAttributeValue( + AttributeConstants.ATTRIBUTE_TEXT).toString()); + WizardDialog dialog = new WizardDialog(getWorkbenchPart().getSite() + .getShell(), wizard); + dialog.create(); + dialog.getShell().setSize(400, 315); + dialog.getShell().setText("BMotion Studio Rename Wizard"); + + if (dialog.open() == WizardDialog.OK) { + String name = wizard.getRenameValue(); + execute(createRenameCommand(name)); + } + } + + private BControl getSelectedBControl() { + List<?> objects = getSelectedObjects(); + if (objects.isEmpty()) { + return null; + } + if (!(objects.get(0) instanceof EditPart)) { + return null; + } + EditPart part = (EditPart) objects.get(0); + return (BControl) part.getModel(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/animation/StaticListenerRegistry.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/animation/StaticListenerRegistry.java index 1e2a30b7a9a74ef566ba838a5f13d32c1f66a4ec..8f7c73084ab2477a8d512b4671fb60de638edd53 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/animation/StaticListenerRegistry.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/animation/StaticListenerRegistry.java @@ -1,67 +1,67 @@ -/** - * (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.bmotionstudio.gef.editor.animation; - -import java.util.HashSet; -import java.util.Set; - -import de.prob.core.IAnimationListener; -import de.prob.core.IComputationListener; -import de.prob.core.ILifecycleListener; -import de.prob.core.domainobjects.Operation; -import de.prob.core.domainobjects.State; - -public class StaticListenerRegistry implements ILifecycleListener, - IComputationListener, IAnimationListener { - - private static final Set<ILifecycleListener> lifeCycleListeners = new HashSet<ILifecycleListener>(); - private static final Set<IComputationListener> computationListeners = new HashSet<IComputationListener>(); - private static final Set<IAnimationListener> animationListeners = new HashSet<IAnimationListener>(); - - public static void registerListener(final ILifecycleListener listener) { - lifeCycleListeners.add(listener); - } - - public static void unregisterListener(final ILifecycleListener listener) { - lifeCycleListeners.remove(listener); - } - - public static void registerListener(final IComputationListener listener) { - computationListeners.add(listener); - } - - public static void unregisterListener(final IComputationListener listener) { - computationListeners.remove(listener); - } - - public static void registerListener(final IAnimationListener listener) { - animationListeners.add(listener); - } - - public static void unregisterListener(final IAnimationListener listener) { - animationListeners.remove(listener); - } - - public void reset() { - for (final ILifecycleListener listener : lifeCycleListeners) { - listener.reset(); - } - } - - public void computedState(final State state) { - for (final IComputationListener listener : computationListeners) { - listener.computedState(state); - } - } - - public void currentStateChanged(final State currentState, - final Operation operation) { - for (final IAnimationListener listener : animationListeners) { - listener.currentStateChanged(currentState, operation); - } - } +/** + * (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.bmotionstudio.gef.editor.animation; + +import java.util.HashSet; +import java.util.Set; + +import de.prob.core.IAnimationListener; +import de.prob.core.IComputationListener; +import de.prob.core.ILifecycleListener; +import de.prob.core.domainobjects.Operation; +import de.prob.core.domainobjects.State; + +public class StaticListenerRegistry implements ILifecycleListener, + IComputationListener, IAnimationListener { + + private static final Set<ILifecycleListener> lifeCycleListeners = new HashSet<ILifecycleListener>(); + private static final Set<IComputationListener> computationListeners = new HashSet<IComputationListener>(); + private static final Set<IAnimationListener> animationListeners = new HashSet<IAnimationListener>(); + + public static void registerListener(final ILifecycleListener listener) { + lifeCycleListeners.add(listener); + } + + public static void unregisterListener(final ILifecycleListener listener) { + lifeCycleListeners.remove(listener); + } + + public static void registerListener(final IComputationListener listener) { + computationListeners.add(listener); + } + + public static void unregisterListener(final IComputationListener listener) { + computationListeners.remove(listener); + } + + public static void registerListener(final IAnimationListener listener) { + animationListeners.add(listener); + } + + public static void unregisterListener(final IAnimationListener listener) { + animationListeners.remove(listener); + } + + public void reset() { + for (final ILifecycleListener listener : lifeCycleListeners) { + listener.reset(); + } + } + + public void computedState(final State state) { + for (final IComputationListener listener : computationListeners) { + listener.computedState(state); + } + } + + public void currentStateChanged(final State currentState, + final Operation operation) { + for (final IAnimationListener listener : animationListeners) { + listener.currentStateChanged(currentState, operation); + } + } } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/AbstractAttribute.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/AbstractAttribute.java index 952e2adb8c611e94217b02f9d0921cfa6542d26c..af18c06a0b60a1dfce1c2a76944e42cf6701466f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/AbstractAttribute.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/AbstractAttribute.java @@ -1,199 +1,199 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import java.util.ArrayList; -import java.util.HashMap; - -import org.eclipse.jface.viewers.ICellEditorValidator; -import org.eclipse.ui.views.properties.IPropertyDescriptor; -import org.eclipse.ui.views.properties.IPropertySource; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; - -/** - * - * Represents an attribute of a {@link BControl}. - * - * @author Lukas Ladenberger - * - */ -public abstract class AbstractAttribute implements IPropertySource, Cloneable { - - public static final String ROOT = "de.bmotionstudio.gef.editor.attribute.BAttributeRoot"; - - private transient HashMap<String, AbstractAttribute> children; - private transient BControl control; - private String group; - private boolean editable; - private boolean show; - private Object value; - - private transient PropertyDescriptor propertyDescriptor; - private transient Object initValue; - - public AbstractAttribute(Object value) { - this.value = value; - this.initValue = value; - this.editable = true; - this.show = true; - } - - private Object readResolve() { - this.initValue = this.value; - return this; - } - - public void addChild(AbstractAttribute atr) { - if (!getChildren().containsKey(atr.getID())) { - getChildren().put(atr.getID(), atr); - } - } - - public Boolean hasChildren() { - return !getChildren().isEmpty(); - } - - public PropertyDescriptor getPropertyDescriptor() { - propertyDescriptor = new PropertyDescriptor(getID(), getName()); - if (editable) { - propertyDescriptor = preparePropertyDescriptor(); - if (propertyDescriptor != null) { - propertyDescriptor.setValidator(new ICellEditorValidator() { - public String isValid(Object value) { - return validateValue(value, control); - } - }); - } - } - return propertyDescriptor; - } - - protected abstract PropertyDescriptor preparePropertyDescriptor(); - - public Object unmarshal(String s) { - return s; - } - - public String getID() { - return getClass().getName(); - } - - public abstract String getName(); - - public void setGroup(AbstractAttribute group) { - setGroup(group.getClass().getName()); - } - - public void setGroup(String group) { - this.group = group; - } - - public String getGroup() { - return group; - } - - public Object getEditableValue() { - return this; - } - - public IPropertyDescriptor[] getPropertyDescriptors() { - ArrayList<IPropertyDescriptor> descriptor = new ArrayList<IPropertyDescriptor>(); - for (AbstractAttribute atr : getChildren().values()) { - descriptor.add(atr.getPropertyDescriptor()); - } - return descriptor.toArray(new IPropertyDescriptor[0]); - } - - public Object getPropertyValue(Object attrID) { - AbstractAttribute atr = getChildren().get(attrID); - if (atr.hasChildren()) { - return atr; - } else { - return atr.getValue(); - } - } - - public boolean isPropertySet(Object id) { - return false; - } - - public void resetPropertyValue(Object id) { - } - - public void setPropertyValue(Object id, Object value) { - AbstractAttribute atr = children.get(id); - atr.setValue(value); - } - - public void setValue(Object value) { - setValue(value, true); - } - - public void setValue(Object value, Boolean firePropertyChange) { - Object oldVal = this.value; - this.value = value; - if (firePropertyChange && control != null) - control.getListeners().firePropertyChange(getID(), oldVal, value); - } - - public void restoreValue() { - Object oldVal = this.value; - this.value = this.initValue; - if (control != null) - control.getListeners().firePropertyChange(getID(), oldVal, value); - } - - public Object getValue() { - return this.value; - } - - public Object getInitValue() { - return initValue; - } - - public HashMap<String, AbstractAttribute> getChildren() { - if (children == null) - children = new HashMap<String, AbstractAttribute>(); - return children; - } - - @Override - public AbstractAttribute clone() throws CloneNotSupportedException { - return (AbstractAttribute) super.clone(); - } - - public void setEditable(boolean editable) { - this.editable = editable; - } - - public boolean isEditable() { - return editable; - } - - public String validateValue(Object value, BControl control) { - return null; - } - - public void setShow(boolean show) { - this.show = show; - } - - public boolean show() { - return show; - } - - public BControl getControl() { - return control; - } - - public void setControl(BControl control) { - this.control = control; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import java.util.ArrayList; +import java.util.HashMap; + +import org.eclipse.jface.viewers.ICellEditorValidator; +import org.eclipse.ui.views.properties.IPropertyDescriptor; +import org.eclipse.ui.views.properties.IPropertySource; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; + +/** + * + * Represents an attribute of a {@link BControl}. + * + * @author Lukas Ladenberger + * + */ +public abstract class AbstractAttribute implements IPropertySource, Cloneable { + + public static final String ROOT = "de.bmotionstudio.gef.editor.attribute.BAttributeRoot"; + + private transient HashMap<String, AbstractAttribute> children; + private transient BControl control; + private String group; + private boolean editable; + private boolean show; + private Object value; + + private transient PropertyDescriptor propertyDescriptor; + private transient Object initValue; + + public AbstractAttribute(Object value) { + this.value = value; + this.initValue = value; + this.editable = true; + this.show = true; + } + + private Object readResolve() { + this.initValue = this.value; + return this; + } + + public void addChild(AbstractAttribute atr) { + if (!getChildren().containsKey(atr.getID())) { + getChildren().put(atr.getID(), atr); + } + } + + public Boolean hasChildren() { + return !getChildren().isEmpty(); + } + + public PropertyDescriptor getPropertyDescriptor() { + propertyDescriptor = new PropertyDescriptor(getID(), getName()); + if (editable) { + propertyDescriptor = preparePropertyDescriptor(); + if (propertyDescriptor != null) { + propertyDescriptor.setValidator(new ICellEditorValidator() { + public String isValid(Object value) { + return validateValue(value, control); + } + }); + } + } + return propertyDescriptor; + } + + protected abstract PropertyDescriptor preparePropertyDescriptor(); + + public Object unmarshal(String s) { + return s; + } + + public String getID() { + return getClass().getName(); + } + + public abstract String getName(); + + public void setGroup(AbstractAttribute group) { + setGroup(group.getClass().getName()); + } + + public void setGroup(String group) { + this.group = group; + } + + public String getGroup() { + return group; + } + + public Object getEditableValue() { + return this; + } + + public IPropertyDescriptor[] getPropertyDescriptors() { + ArrayList<IPropertyDescriptor> descriptor = new ArrayList<IPropertyDescriptor>(); + for (AbstractAttribute atr : getChildren().values()) { + descriptor.add(atr.getPropertyDescriptor()); + } + return descriptor.toArray(new IPropertyDescriptor[0]); + } + + public Object getPropertyValue(Object attrID) { + AbstractAttribute atr = getChildren().get(attrID); + if (atr.hasChildren()) { + return atr; + } else { + return atr.getValue(); + } + } + + public boolean isPropertySet(Object id) { + return false; + } + + public void resetPropertyValue(Object id) { + } + + public void setPropertyValue(Object id, Object value) { + AbstractAttribute atr = children.get(id); + atr.setValue(value); + } + + public void setValue(Object value) { + setValue(value, true); + } + + public void setValue(Object value, Boolean firePropertyChange) { + Object oldVal = this.value; + this.value = value; + if (firePropertyChange && control != null) + control.getListeners().firePropertyChange(getID(), oldVal, value); + } + + public void restoreValue() { + Object oldVal = this.value; + this.value = this.initValue; + if (control != null) + control.getListeners().firePropertyChange(getID(), oldVal, value); + } + + public Object getValue() { + return this.value; + } + + public Object getInitValue() { + return initValue; + } + + public HashMap<String, AbstractAttribute> getChildren() { + if (children == null) + children = new HashMap<String, AbstractAttribute>(); + return children; + } + + @Override + public AbstractAttribute clone() throws CloneNotSupportedException { + return (AbstractAttribute) super.clone(); + } + + public void setEditable(boolean editable) { + this.editable = editable; + } + + public boolean isEditable() { + return editable; + } + + public String validateValue(Object value, BControl control) { + return null; + } + + public void setShow(boolean show) { + this.show = show; + } + + public boolean show() { + return show; + } + + public BControl getControl() { + return control; + } + + public void setControl(BControl control) { + this.control = control; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeAlpha.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeAlpha.java index ced44636ecd9f445c0418cb1e6064b28bcff8ac2..fe192157564608b16cc527627ed8ff49cd13ec62 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeAlpha.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeAlpha.java @@ -1,49 +1,49 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.SliderPropertyDescriptor; - -public class BAttributeAlpha extends AbstractAttribute { - - public BAttributeAlpha(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - SliderPropertyDescriptor descriptor = new SliderPropertyDescriptor( - getID(), getName()); - return descriptor; - } - - @Override - public String validateValue(Object value, BControl control) { - if (!(String.valueOf(value)).trim().matches("\\d*")) { - return "Value must be a number"; - } - - if ((String.valueOf(value)).trim().length() == 0) { - return "Value must not be empty string"; - } - - if (Integer.valueOf(value.toString()) > 255 - || Integer.valueOf(value.toString()) < 0) { - return "Only a range from 0 to 255 is allowed"; - } - - return null; - } - - @Override - public String getName() { - return "Alpha"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.SliderPropertyDescriptor; + +public class BAttributeAlpha extends AbstractAttribute { + + public BAttributeAlpha(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + SliderPropertyDescriptor descriptor = new SliderPropertyDescriptor( + getID(), getName()); + return descriptor; + } + + @Override + public String validateValue(Object value, BControl control) { + if (!(String.valueOf(value)).trim().matches("\\d*")) { + return "Value must be a number"; + } + + if ((String.valueOf(value)).trim().length() == 0) { + return "Value must not be empty string"; + } + + if (Integer.valueOf(value.toString()) > 255 + || Integer.valueOf(value.toString()) < 0) { + return "Only a range from 0 to 255 is allowed"; + } + + return null; + } + + @Override + public String getName() { + return "Alpha"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundColor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundColor.java index 72d0ad68e8060f0add59abcfb971d8d1fe4461c3..0023246f77f3519457e9c64abf7ba27698fff49f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundColor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundColor.java @@ -1,55 +1,55 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.swt.graphics.RGB; -import org.eclipse.ui.views.properties.ColorPropertyDescriptor; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BAttributeBackgroundColor extends AbstractAttribute { - - public BAttributeBackgroundColor(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new ColorPropertyDescriptor(getID(), getName()); - } - - @Override - public String validateValue(Object value, BControl control) { - // TODO: Implement me! - return null; - } - - @Override - public String getName() { - return "Background-Color"; - } - - @Override - public Object unmarshal(String s) { - - String colorStr = s.toLowerCase().replace(" ", ""); - colorStr = colorStr.replace("rgb", ""); - colorStr = colorStr.replace("}", ""); - colorStr = colorStr.replace("{", ""); - String[] str = String.valueOf(colorStr).split("\\,"); - if (str.length == 3) { - int red = Integer.valueOf(str[0]); - int green = Integer.valueOf(str[1]); - int blue = Integer.valueOf(str[2]); - return new RGB(red, green, blue); - } else { - return new RGB(192, 192, 192); - } - - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.swt.graphics.RGB; +import org.eclipse.ui.views.properties.ColorPropertyDescriptor; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BAttributeBackgroundColor extends AbstractAttribute { + + public BAttributeBackgroundColor(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new ColorPropertyDescriptor(getID(), getName()); + } + + @Override + public String validateValue(Object value, BControl control) { + // TODO: Implement me! + return null; + } + + @Override + public String getName() { + return "Background-Color"; + } + + @Override + public Object unmarshal(String s) { + + String colorStr = s.toLowerCase().replace(" ", ""); + colorStr = colorStr.replace("rgb", ""); + colorStr = colorStr.replace("}", ""); + colorStr = colorStr.replace("{", ""); + String[] str = String.valueOf(colorStr).split("\\,"); + if (str.length == 3) { + int red = Integer.valueOf(str[0]); + int green = Integer.valueOf(str[1]); + int blue = Integer.valueOf(str[2]); + return new RGB(red, green, blue); + } else { + return new RGB(192, 192, 192); + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundVisible.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundVisible.java index 2fe7e5f98645f83461e615a4987962f3ab205895..05c468b63454bd7836f67c8c319cb7660f76de34 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundVisible.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeBackgroundVisible.java @@ -1,44 +1,44 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; - -public class BAttributeBackgroundVisible extends AbstractAttribute { - - public BAttributeBackgroundVisible(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new CheckboxPropertyDescriptor(getID(), getName()); - } - - @Override - public String validateValue(Object value, BControl control) { - if ((String.valueOf(value)).trim().equalsIgnoreCase("true") - || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { - return null; - } else { - return "Value must be a Boolean value (\"true\" or \"false\")"; - } - } - - @Override - public String getName() { - return "Visible"; - } - - @Override - public Object unmarshal(String s) { - return Boolean.valueOf(s); - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; + +public class BAttributeBackgroundVisible extends AbstractAttribute { + + public BAttributeBackgroundVisible(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new CheckboxPropertyDescriptor(getID(), getName()); + } + + @Override + public String validateValue(Object value, BControl control) { + if ((String.valueOf(value)).trim().equalsIgnoreCase("true") + || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { + return null; + } else { + return "Value must be a Boolean value (\"true\" or \"false\")"; + } + } + + @Override + public String getName() { + return "Visible"; + } + + @Override + public Object unmarshal(String s) { + return Boolean.valueOf(s); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeEnabled.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeEnabled.java index 90e17ef0f039ba5e219e2213aafc74a6b01b88df..170e1dfde4ec606c0932fe2fcb03fd8eb0ec7b0e 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeEnabled.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeEnabled.java @@ -1,44 +1,44 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; - -public class BAttributeEnabled extends AbstractAttribute { - - public BAttributeEnabled(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new CheckboxPropertyDescriptor(getID(), getName()); - } - - @Override - public String validateValue(final Object value, BControl control) { - if ((String.valueOf(value)).trim().equalsIgnoreCase("true") - || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { - return null; - } else { - return "Value must be a Boolean value (\"true\" or \"false\")"; - } - } - - @Override - public String getName() { - return "Enabled"; - } - - @Override - public Object unmarshal(String s) { - return Boolean.valueOf(s); - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; + +public class BAttributeEnabled extends AbstractAttribute { + + public BAttributeEnabled(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new CheckboxPropertyDescriptor(getID(), getName()); + } + + @Override + public String validateValue(final Object value, BControl control) { + if ((String.valueOf(value)).trim().equalsIgnoreCase("true") + || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { + return null; + } else { + return "Value must be a Boolean value (\"true\" or \"false\")"; + } + } + + @Override + public String getName() { + return "Enabled"; + } + + @Override + public Object unmarshal(String s) { + return Boolean.valueOf(s); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillColor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillColor.java index f9ad86fc83d0eed452a95766ce6b7dad9730bcf0..22686e0e46b102955a8717ba2259873f5bd4a564 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillColor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillColor.java @@ -1,47 +1,47 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.swt.graphics.RGB; -import org.eclipse.ui.views.properties.ColorPropertyDescriptor; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -public class BAttributeFillColor extends AbstractAttribute { - - public BAttributeFillColor(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new ColorPropertyDescriptor(getID(), getName()); - } - - @Override - public String getName() { - return "Fill-Color"; - } - - @Override - public Object unmarshal(String s) { - - String colorStr = s.toLowerCase().replace(" ", ""); - colorStr = colorStr.replace("rgb", ""); - colorStr = colorStr.replace("}", ""); - colorStr = colorStr.replace("{", ""); - String[] str = String.valueOf(colorStr).split("\\,"); - if (str.length == 3) { - int red = Integer.valueOf(str[0]); - int green = Integer.valueOf(str[1]); - int blue = Integer.valueOf(str[2]); - return new RGB(red, green, blue); - } else { - return new RGB(192, 192, 192); - } - - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.swt.graphics.RGB; +import org.eclipse.ui.views.properties.ColorPropertyDescriptor; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +public class BAttributeFillColor extends AbstractAttribute { + + public BAttributeFillColor(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new ColorPropertyDescriptor(getID(), getName()); + } + + @Override + public String getName() { + return "Fill-Color"; + } + + @Override + public Object unmarshal(String s) { + + String colorStr = s.toLowerCase().replace(" ", ""); + colorStr = colorStr.replace("rgb", ""); + colorStr = colorStr.replace("}", ""); + colorStr = colorStr.replace("{", ""); + String[] str = String.valueOf(colorStr).split("\\,"); + if (str.length == 3) { + int red = Integer.valueOf(str[0]); + int green = Integer.valueOf(str[1]); + int blue = Integer.valueOf(str[2]); + return new RGB(red, green, blue); + } else { + return new RGB(192, 192, 192); + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillHeight.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillHeight.java index 30e0b429641a6912797422e6e31d5cfea752b016..a413e887dfe55ba718af36203bdf13d490f81643 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillHeight.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFillHeight.java @@ -1,27 +1,27 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; -import org.eclipse.ui.views.properties.TextPropertyDescriptor; - -public class BAttributeFillHeight extends AbstractAttribute { - - public BAttributeFillHeight(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new TextPropertyDescriptor(getID(), getName()); - } - - @Override - public String getName() { - return "Fill-Height"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; +import org.eclipse.ui.views.properties.TextPropertyDescriptor; + +public class BAttributeFillHeight extends AbstractAttribute { + + public BAttributeFillHeight(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new TextPropertyDescriptor(getID(), getName()); + } + + @Override + public String getName() { + return "Fill-Height"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFont.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFont.java index 9f8c3d87d53b33eeacc2cc82402a5a971d55a400..85986759f8aed85204a780a1d4f54082296b91f0 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFont.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeFont.java @@ -1,28 +1,28 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.property.FontPropertyDescriptor; - -public class BAttributeFont extends AbstractAttribute { - - public BAttributeFont(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new FontPropertyDescriptor(getID(), getName()); - } - - @Override - public String getName() { - return "Font"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.property.FontPropertyDescriptor; + +public class BAttributeFont extends AbstractAttribute { + + public BAttributeFont(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new FontPropertyDescriptor(getID(), getName()); + } + + @Override + public String getName() { + return "Font"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeHeight.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeHeight.java index a4eec8e565146d2ea80384a8f9878286e95a3deb..5947e5cd808c696ae11196e1b7eddc77c2b98fb7 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeHeight.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeHeight.java @@ -1,42 +1,42 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; - -public class BAttributeHeight extends AbstractAttribute { - - public BAttributeHeight(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( - getID(), getName()); - return descriptor; - } - - @Override - public String validateValue(Object value, BControl control) { - if (!(String.valueOf(value)).trim().matches("\\d*")) { - return "Value must be a number"; - } - if ((String.valueOf(value)).trim().length() == 0) { - return "Value must not be empty string"; - } - return null; - } - - @Override - public String getName() { - return "Height"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; + +public class BAttributeHeight extends AbstractAttribute { + + public BAttributeHeight(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( + getID(), getName()); + return descriptor; + } + + @Override + public String validateValue(Object value, BControl control) { + if (!(String.valueOf(value)).trim().matches("\\d*")) { + return "Value must be a number"; + } + if ((String.valueOf(value)).trim().length() == 0) { + return "Value must not be empty string"; + } + return null; + } + + @Override + public String getName() { + return "Height"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeID.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeID.java index 21ce6046376c7d88e8275147f5984fe8ec02ac4b..b181122cdbd830bab5682d75b05d494f0fb8e00d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeID.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeID.java @@ -1,45 +1,45 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; -import org.eclipse.ui.views.properties.TextPropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BAttributeID extends AbstractAttribute { - - public BAttributeID(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - TextPropertyDescriptor descriptor = new TextPropertyDescriptor(getID(), - getName()); - return descriptor; - } - - @Override - public String validateValue(Object value, BControl control) { - if (((String) value).trim().length() == 0) { - return "Value must not be empty string"; - } - if (!(String.valueOf(value)).trim().matches("^[a-zA-Z_0-9]*")) { - return "Special characters are not allowed."; - } - if (control.getVisualization().checkIfIdExists((String) value)) { - return "ID already exists"; - } - return null; - } - - @Override - public String getName() { - return "a1:ID"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; +import org.eclipse.ui.views.properties.TextPropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BAttributeID extends AbstractAttribute { + + public BAttributeID(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + TextPropertyDescriptor descriptor = new TextPropertyDescriptor(getID(), + getName()); + return descriptor; + } + + @Override + public String validateValue(Object value, BControl control) { + if (((String) value).trim().length() == 0) { + return "Value must not be empty string"; + } + if (!(String.valueOf(value)).trim().matches("^[a-zA-Z_0-9]*")) { + return "Special characters are not allowed."; + } + if (control.getVisualization().checkIfIdExists((String) value)) { + return "ID already exists"; + } + return null; + } + + @Override + public String getName() { + return "a1:ID"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeImage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeImage.java index d17d58ffc6b6362ec480380b5f2d126026a800d6..86f1d299bf2ef2cf3811c6eee0916e062ae9605f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeImage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeImage.java @@ -1,45 +1,45 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import java.io.File; - -import org.eclipse.core.resources.IFile; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.ImagePropertyDescriptor; - -public class BAttributeImage extends AbstractAttribute { - - public BAttributeImage(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new ImagePropertyDescriptor(getID(), getName()); - } - - public String validateValue(Object value, BControl control) { - if (value != null) { - String fImage = value.toString(); - IFile pFile = control.getVisualization().getProjectFile(); - String myPath = (pFile.getProject().getLocation() + "/images/" + fImage) - .replace("file:", ""); - if (!new File(myPath).exists()) { - return "No such image in your library: " + fImage; - } - } - return null; - } - - @Override - public String getName() { - return "Image"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import java.io.File; + +import org.eclipse.core.resources.IFile; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.ImagePropertyDescriptor; + +public class BAttributeImage extends AbstractAttribute { + + public BAttributeImage(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new ImagePropertyDescriptor(getID(), getName()); + } + + public String validateValue(Object value, BControl control) { + if (value != null) { + String fImage = value.toString(); + IFile pFile = control.getVisualization().getProjectFile(); + String myPath = (pFile.getProject().getLocation() + "/images/" + fImage) + .replace("file:", ""); + if (!new File(myPath).exists()) { + return "No such image in your library: " + fImage; + } + } + return null; + } + + @Override + public String getName() { + return "Image"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureInterval.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureInterval.java index d9892f8a1ec20736b6078974084a56626faf9f6f..8e36529da97e4f28f377a5bab68dd903a1ac4db0 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureInterval.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureInterval.java @@ -1,27 +1,27 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; -import org.eclipse.ui.views.properties.TextPropertyDescriptor; - -public class BAttributeMeasureInterval extends AbstractAttribute { - - public BAttributeMeasureInterval(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new TextPropertyDescriptor(getID(), getName()); - } - - @Override - public String getName() { - return "Measure-Interval"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; +import org.eclipse.ui.views.properties.TextPropertyDescriptor; + +public class BAttributeMeasureInterval extends AbstractAttribute { + + public BAttributeMeasureInterval(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new TextPropertyDescriptor(getID(), getName()); + } + + @Override + public String getName() { + return "Measure-Interval"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureMaxPos.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureMaxPos.java index dbe52aadb25e6504823b03951e61d9f771aac772..7adafa6618d7a569717a072dc82ffb156e080480 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureMaxPos.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeMeasureMaxPos.java @@ -1,27 +1,27 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; -import org.eclipse.ui.views.properties.TextPropertyDescriptor; - -public class BAttributeMeasureMaxPos extends AbstractAttribute { - - public BAttributeMeasureMaxPos(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new TextPropertyDescriptor(getID(), getName()); - } - - @Override - public String getName() { - return "Measure-Max-Pos"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; +import org.eclipse.ui.views.properties.TextPropertyDescriptor; + +public class BAttributeMeasureMaxPos extends AbstractAttribute { + + public BAttributeMeasureMaxPos(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new TextPropertyDescriptor(getID(), getName()); + } + + @Override + public String getName() { + return "Measure-Max-Pos"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeOutlineAlpha.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeOutlineAlpha.java index dd3ce6d151ad5b70e2e2f2af0578049f3136ab73..f583a8f03f37c48592c2358a6217a1f2b347b7b3 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeOutlineAlpha.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeOutlineAlpha.java @@ -1,50 +1,50 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.SliderPropertyDescriptor; - -public class BAttributeOutlineAlpha extends AbstractAttribute { - - public BAttributeOutlineAlpha(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - SliderPropertyDescriptor descriptor = new SliderPropertyDescriptor( - getID(), getName()); - return descriptor; - } - - public String validateValue(Object value, BControl control) { - - if (!(String.valueOf(value)).trim().matches("\\d*")) { - return "Value must be a number"; - } - - if ((String.valueOf(value)).trim().length() == 0) { - return "Value must not be empty string"; - } - - if (Integer.valueOf(value.toString()) > 255 - || Integer.valueOf(value.toString()) < 0) { - return "Only a range from 0 to 255 is allowed"; - } - - return null; - - } - - @Override - public String getName() { - return "Outline-Alpha"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.SliderPropertyDescriptor; + +public class BAttributeOutlineAlpha extends AbstractAttribute { + + public BAttributeOutlineAlpha(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + SliderPropertyDescriptor descriptor = new SliderPropertyDescriptor( + getID(), getName()); + return descriptor; + } + + public String validateValue(Object value, BControl control) { + + if (!(String.valueOf(value)).trim().matches("\\d*")) { + return "Value must be a number"; + } + + if ((String.valueOf(value)).trim().length() == 0) { + return "Value must not be empty string"; + } + + if (Integer.valueOf(value.toString()) > 255 + || Integer.valueOf(value.toString()) < 0) { + return "Only a range from 0 to 255 is allowed"; + } + + return null; + + } + + @Override + public String getName() { + return "Outline-Alpha"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeShowMeasure.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeShowMeasure.java index e5aa9cb4ea0402e7081b9747059b567822dabc2f..f8777dd552528ebab78e23ddfcf55a74763fb1f9 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeShowMeasure.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeShowMeasure.java @@ -1,44 +1,44 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; - -public class BAttributeShowMeasure extends AbstractAttribute { - - public BAttributeShowMeasure(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new CheckboxPropertyDescriptor(getID(), getName()); - } - - @Override - public String validateValue(Object value, BControl control) { - if ((String.valueOf(value)).trim().equalsIgnoreCase("true") - || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { - return null; - } else { - return "Value must be a Boolean value (\"true\" or \"false\")"; - } - } - - @Override - public String getName() { - return "Show-Measure"; - } - - @Override - public Object unmarshal(String s) { - return Boolean.valueOf(s); - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; + +public class BAttributeShowMeasure extends AbstractAttribute { + + public BAttributeShowMeasure(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new CheckboxPropertyDescriptor(getID(), getName()); + } + + @Override + public String validateValue(Object value, BControl control) { + if ((String.valueOf(value)).trim().equalsIgnoreCase("true") + || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { + return null; + } else { + return "Value must be a Boolean value (\"true\" or \"false\")"; + } + } + + @Override + public String getName() { + return "Show-Measure"; + } + + @Override + public Object unmarshal(String s) { + return Boolean.valueOf(s); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeText.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeText.java index d9d0ab66bd3b789452376e3505bca4542a911033..97d071630c2c0df0fdc1159ecb2d74de2f47fd23 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeText.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeText.java @@ -1,27 +1,27 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; -import org.eclipse.ui.views.properties.TextPropertyDescriptor; - -public class BAttributeText extends AbstractAttribute { - - public BAttributeText(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new TextPropertyDescriptor(getID(), getName()); - } - - @Override - public String getName() { - return "Text"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; +import org.eclipse.ui.views.properties.TextPropertyDescriptor; + +public class BAttributeText extends AbstractAttribute { + + public BAttributeText(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new TextPropertyDescriptor(getID(), getName()); + } + + @Override + public String getName() { + return "Text"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeTextColor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeTextColor.java index 4e2da94ca5f29e91e6425ae3d25b9f36acfcfa69..dbba315d244d7655012a87b6072cc0db9ca37eda 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeTextColor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeTextColor.java @@ -1,55 +1,55 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.swt.graphics.RGB; -import org.eclipse.ui.views.properties.ColorPropertyDescriptor; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BAttributeTextColor extends AbstractAttribute { - - public BAttributeTextColor(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new ColorPropertyDescriptor(getID(), getName()); - } - - @Override - public String validateValue(Object value, BControl control) { - // TODO: Implement me! - return null; - } - - @Override - public String getName() { - return "Text-Color"; - } - - @Override - public Object unmarshal(String s) { - - String colorStr = s.toLowerCase().replace(" ", ""); - colorStr = colorStr.replace("rgb", ""); - colorStr = colorStr.replace("}", ""); - colorStr = colorStr.replace("{", ""); - String[] str = String.valueOf(colorStr).split("\\,"); - if (str.length == 3) { - int red = Integer.valueOf(str[0]); - int green = Integer.valueOf(str[1]); - int blue = Integer.valueOf(str[2]); - return new RGB(red, green, blue); - } else { - return new RGB(192, 192, 192); - } - - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.swt.graphics.RGB; +import org.eclipse.ui.views.properties.ColorPropertyDescriptor; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BAttributeTextColor extends AbstractAttribute { + + public BAttributeTextColor(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new ColorPropertyDescriptor(getID(), getName()); + } + + @Override + public String validateValue(Object value, BControl control) { + // TODO: Implement me! + return null; + } + + @Override + public String getName() { + return "Text-Color"; + } + + @Override + public Object unmarshal(String s) { + + String colorStr = s.toLowerCase().replace(" ", ""); + colorStr = colorStr.replace("rgb", ""); + colorStr = colorStr.replace("}", ""); + colorStr = colorStr.replace("{", ""); + String[] str = String.valueOf(colorStr).split("\\,"); + if (str.length == 3) { + int red = Integer.valueOf(str[0]); + int green = Integer.valueOf(str[1]); + int blue = Integer.valueOf(str[2]); + return new RGB(red, green, blue); + } else { + return new RGB(192, 192, 192); + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeVisible.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeVisible.java index 96961a53dab4e56bb39a99a59c2d84b93aea36fe..bbf89608770e925157c6fcf401e58fcd3338d59b 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeVisible.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeVisible.java @@ -1,44 +1,44 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; - -public class BAttributeVisible extends AbstractAttribute { - - public BAttributeVisible(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - return new CheckboxPropertyDescriptor(getID(), getName()); - } - - @Override - public String validateValue(Object value, BControl control) { - if ((String.valueOf(value)).trim().equalsIgnoreCase("true") - || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { - return null; - } else { - return "Value must be a Boolean value (\"true\" or \"false\")"; - } - } - - @Override - public String getName() { - return "a3:Visible"; - } - - @Override - public Object unmarshal(String s) { - return Boolean.valueOf(s); - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.CheckboxPropertyDescriptor; + +public class BAttributeVisible extends AbstractAttribute { + + public BAttributeVisible(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + return new CheckboxPropertyDescriptor(getID(), getName()); + } + + @Override + public String validateValue(Object value, BControl control) { + if ((String.valueOf(value)).trim().equalsIgnoreCase("true") + || (String.valueOf(value)).trim().equalsIgnoreCase("false")) { + return null; + } else { + return "Value must be a Boolean value (\"true\" or \"false\")"; + } + } + + @Override + public String getName() { + return "a3:Visible"; + } + + @Override + public Object unmarshal(String s) { + return Boolean.valueOf(s); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeWidth.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeWidth.java index bcb310e77a51b6c9f68576b6de16f70a6c2dd351..34844653d9226fbca2ab5020f527fb7d43718cc0 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeWidth.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeWidth.java @@ -1,42 +1,42 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; - -public class BAttributeWidth extends AbstractAttribute { - - public BAttributeWidth(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( - getID(), getName()); - return descriptor; - } - - @Override - public String validateValue(Object value, BControl control) { - if (!(String.valueOf(value)).trim().matches("\\d*")) { - return "Value must be a number"; - } - if ((String.valueOf(value)).trim().length() == 0) { - return "Value must not be empty string"; - } - return null; - } - - @Override - public String getName() { - return "Width"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; + +public class BAttributeWidth extends AbstractAttribute { + + public BAttributeWidth(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( + getID(), getName()); + return descriptor; + } + + @Override + public String validateValue(Object value, BControl control) { + if (!(String.valueOf(value)).trim().matches("\\d*")) { + return "Value must be a number"; + } + if ((String.valueOf(value)).trim().length() == 0) { + return "Value must not be empty string"; + } + return null; + } + + @Override + public String getName() { + return "Width"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeX.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeX.java index 2ff72c75024892ef73ef0c1edcde72af764a319a..e3f911398536a6f4a871fdd8b037608462a064a0 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeX.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeX.java @@ -1,42 +1,42 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; - -public class BAttributeX extends AbstractAttribute { - - public BAttributeX(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( - getID(), getName()); - return descriptor; - } - - @Override - public String validateValue(Object value, BControl control) { - if (!(String.valueOf(value)).trim().matches("\\d*")) { - return "Value must be a number"; - } - if ((String.valueOf(value)).trim().length() == 0) { - return "Value must not be empty string"; - } - return null; - } - - @Override - public String getName() { - return "X"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; + +public class BAttributeX extends AbstractAttribute { + + public BAttributeX(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( + getID(), getName()); + return descriptor; + } + + @Override + public String validateValue(Object value, BControl control) { + if (!(String.valueOf(value)).trim().matches("\\d*")) { + return "Value must be a number"; + } + if ((String.valueOf(value)).trim().length() == 0) { + return "Value must not be empty string"; + } + return null; + } + + @Override + public String getName() { + return "X"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeY.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeY.java index a48a0e28ef74a9324e999255f6c93cf1f8a85385..45c5959a7837d01f33fe22d722db436167b3d7fa 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeY.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/attribute/BAttributeY.java @@ -1,42 +1,42 @@ -/** - * (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.bmotionstudio.gef.editor.attribute; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; - -public class BAttributeY extends AbstractAttribute { - - public BAttributeY(Object value) { - super(value); - } - - public PropertyDescriptor preparePropertyDescriptor() { - IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( - getID(), getName()); - return descriptor; - } - - @Override - public String validateValue(Object value, BControl control) { - if (!(String.valueOf(value)).trim().matches("\\d*")) { - return "Value must be a number"; - } - if ((String.valueOf(value)).trim().length() == 0) { - return "Value must not be empty string"; - } - return null; - } - - @Override - public String getName() { - return "Y"; - } - -} +/** + * (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.bmotionstudio.gef.editor.attribute; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.IntegerPropertyDescriptor; + +public class BAttributeY extends AbstractAttribute { + + public BAttributeY(Object value) { + super(value); + } + + public PropertyDescriptor preparePropertyDescriptor() { + IntegerPropertyDescriptor descriptor = new IntegerPropertyDescriptor( + getID(), getName()); + return descriptor; + } + + @Override + public String validateValue(Object value, BControl control) { + if (!(String.valueOf(value)).trim().matches("\\d*")) { + return "Value must be a number"; + } + if ((String.valueOf(value)).trim().length() == 0) { + return "Value must not be empty string"; + } + return null; + } + + @Override + public String getName() { + return "Y"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BControlChangeLayoutCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BControlChangeLayoutCommand.java index 0362ff942c735c321c4302bd39ce36c6ecf03621..96effb5f2ec96106463679be4b9335ac54b4856c 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BControlChangeLayoutCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BControlChangeLayoutCommand.java @@ -1,37 +1,37 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import org.eclipse.draw2d.geometry.Rectangle; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BControlChangeLayoutCommand extends AbstractLayoutCommand { - - private BControl control; - private Rectangle newLayout; - private Rectangle oldLayout; - - public void execute() { - control.setLayout(newLayout); - } - - public void setConstraint(Rectangle rect) { - newLayout = rect; - } - - public void setModel(Object model) { - control = (BControl) model; - oldLayout = control.getLayout(); - } - - @Override - public void undo() { - control.setLayout(oldLayout); - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import org.eclipse.draw2d.geometry.Rectangle; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BControlChangeLayoutCommand extends AbstractLayoutCommand { + + private BControl control; + private Rectangle newLayout; + private Rectangle oldLayout; + + public void execute() { + control.setLayout(newLayout); + } + + public void setConstraint(Rectangle rect) { + newLayout = rect; + } + + public void setModel(Object model) { + control = (BControl) model; + oldLayout = control.getLayout(); + } + + @Override + public void undo() { + control.setLayout(oldLayout); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomCommand.java index 124b9b8f3aae619fc782a0835d6c2eec20da22b5..601e6bb35cf0c5c8e4a043a8544c2552dc27509b 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomCommand.java @@ -1,36 +1,36 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BringToBottomCommand extends AbstractBringToCommand { - - public void execute() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - Integer oldIndex = parent.getChildrenArray().indexOf(control); - getOldIndexMap().put(control, oldIndex); - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(0, control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - - public void undo() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(getOldIndexMap().get(control), - control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BringToBottomCommand extends AbstractBringToCommand { + + public void execute() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + Integer oldIndex = parent.getChildrenArray().indexOf(control); + getOldIndexMap().put(control, oldIndex); + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(0, control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + + public void undo() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(getOldIndexMap().get(control), + control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomStepCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomStepCommand.java index 45368b844f6c1880871fc8667b7c29016601753b..7e5dff77861ab06ba45e5d306d4155c6bd0b54cf 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomStepCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToBottomStepCommand.java @@ -1,38 +1,38 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BringToBottomStepCommand extends AbstractBringToCommand { - - public void execute() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - Integer oldIndex = parent.getChildrenArray().indexOf(control); - getOldIndexMap().put(control, oldIndex); - if (oldIndex > 0) { - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(oldIndex - 1, control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - } - - public void undo() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(getOldIndexMap().get(control), - control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BringToBottomStepCommand extends AbstractBringToCommand { + + public void execute() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + Integer oldIndex = parent.getChildrenArray().indexOf(control); + getOldIndexMap().put(control, oldIndex); + if (oldIndex > 0) { + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(oldIndex - 1, control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + } + + public void undo() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(getOldIndexMap().get(control), + control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopCommand.java index 38c7631409f6d1db88c653fcde2bdf0ec93995f0..716c1454a766ebf1e24f7d4ede5fa3dd79acccd9 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopCommand.java @@ -1,37 +1,37 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BringToTopCommand extends AbstractBringToCommand { - - public void execute() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - Integer oldIndex = parent.getChildrenArray().indexOf(control); - getOldIndexMap().put(control, oldIndex); - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(parent.getChildrenArray().size(), - control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - - public void undo() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(getOldIndexMap().get(control), - control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BringToTopCommand extends AbstractBringToCommand { + + public void execute() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + Integer oldIndex = parent.getChildrenArray().indexOf(control); + getOldIndexMap().put(control, oldIndex); + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(parent.getChildrenArray().size(), + control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + + public void undo() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(getOldIndexMap().get(control), + control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopStepCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopStepCommand.java index 5e82ce35d56b96bb6a1fa30ea1741c9bcb93979e..3560448e1c245684e4a599ef4f14f421f55a8069 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopStepCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/BringToTopStepCommand.java @@ -1,38 +1,38 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class BringToTopStepCommand extends AbstractBringToCommand { - - public void execute() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - Integer oldIndex = parent.getChildrenArray().indexOf(control); - getOldIndexMap().put(control, oldIndex); - if (oldIndex < parent.getChildrenArray().size() - 1) { - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(oldIndex + 1, control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - } - - public void undo() { - for (BControl control : getControlList()) { - BControl parent = control.getParent(); - parent.getChildrenArray().remove(control); - parent.getChildrenArray().add(getOldIndexMap().get(control), - control); - parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, - null, null); - } - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class BringToTopStepCommand extends AbstractBringToCommand { + + public void execute() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + Integer oldIndex = parent.getChildrenArray().indexOf(control); + getOldIndexMap().put(control, oldIndex); + if (oldIndex < parent.getChildrenArray().size() - 1) { + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(oldIndex + 1, control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + } + + public void undo() { + for (BControl control : getControlList()) { + BControl parent = control.getParent(); + parent.getChildrenArray().remove(control); + parent.getChildrenArray().add(getOldIndexMap().get(control), + control); + parent.getListeners().firePropertyChange(BControl.PROPERTY_ADD, + null, null); + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CopyCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CopyCommand.java index a61c0006d13c1ca8eab443da6a991f83019ab537..2fa07577284289e76f55eff2de0b69345de5ae8a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CopyCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CopyCommand.java @@ -1,59 +1,59 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import java.util.ArrayList; -import java.util.Iterator; - -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.ui.actions.Clipboard; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class CopyCommand extends Command { - - private ArrayList<BControl> list = new ArrayList<BControl>(); - - public boolean addElement(BControl control) { - if (!list.contains(control)) { - return list.add(control); - } - return false; - } - - @Override - public boolean canExecute() { - if (list == null || list.isEmpty()) - return false; - Iterator<BControl> it = list.iterator(); - while (it.hasNext()) { - if (!isCopyableControl(it.next())) - return false; - } - return true; - } - - @Override - public void execute() { - if (canExecute()) { - Clipboard.getDefault().setContents(new CopyPasteHelper(list, 10)); - } - } - - @Override - public boolean canUndo() { - return false; - } - - public boolean isCopyableControl(BControl control) { - if (!(control instanceof Visualization)) - return true; - return false; - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import java.util.ArrayList; +import java.util.Iterator; + +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.ui.actions.Clipboard; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class CopyCommand extends Command { + + private ArrayList<BControl> list = new ArrayList<BControl>(); + + public boolean addElement(BControl control) { + if (!list.contains(control)) { + return list.add(control); + } + return false; + } + + @Override + public boolean canExecute() { + if (list == null || list.isEmpty()) + return false; + Iterator<BControl> it = list.iterator(); + while (it.hasNext()) { + if (!isCopyableControl(it.next())) + return false; + } + return true; + } + + @Override + public void execute() { + if (canExecute()) { + Clipboard.getDefault().setContents(new CopyPasteHelper(list, 10)); + } + } + + @Override + public boolean canUndo() { + return false; + } + + public boolean isCopyableControl(BControl control) { + if (!(control instanceof Visualization)) + return true; + return false; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CreateCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CreateCommand.java index e895d1f98ce6b77b92c103372c27b08cfdd641e9..f2461937099b0b4077a63a7f0f1b2ce3f7ce1a16 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CreateCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/CreateCommand.java @@ -1,60 +1,60 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.gef.commands.Command; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class CreateCommand extends Command { - - private BControl parent; - private BControl child; - private int index = -1; - - public CreateCommand(BControl child, BControl parent) { - super(); - this.parent = parent; - this.child = child; - } - - public void setLayout(Rectangle r) { - if (child == null) - return; - child.setLayout(r); - } - - @Override - public boolean canExecute() { - if (parent == null || child == null) - return false; - return true; - } - - @Override - public void execute() { - parent.addChild(child, index); - } - - @Override - public boolean canUndo() { - if (parent == null || child == null) - return false; - return parent.contains(child); - } - - @Override - public void undo() { - parent.removeChild(child); - } - - public void setIndex(int index) { - this.index = index; - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.gef.commands.Command; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class CreateCommand extends Command { + + private BControl parent; + private BControl child; + private int index = -1; + + public CreateCommand(BControl child, BControl parent) { + super(); + this.parent = parent; + this.child = child; + } + + public void setLayout(Rectangle r) { + if (child == null) + return; + child.setLayout(r); + } + + @Override + public boolean canExecute() { + if (parent == null || child == null) + return false; + return true; + } + + @Override + public void execute() { + parent.addChild(child, index); + } + + @Override + public boolean canUndo() { + if (parent == null || child == null) + return false; + return parent.contains(child); + } + + @Override + public void undo() { + parent.removeChild(child); + } + + public void setIndex(int index) { + this.index = index; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/DeleteCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/DeleteCommand.java index a4db8f4ea11f5f0032076c8abb7f1aabd29bd547..c6abca10c2aa75b03af902e081231c0bb5586b12 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/DeleteCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/DeleteCommand.java @@ -1,47 +1,47 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import org.eclipse.gef.commands.Command; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class DeleteCommand extends Command { - - private BControl control; - private BControl parent; - - public DeleteCommand(BControl control, BControl parent) { - this.control = control; - this.parent = parent; - } - - @Override - public boolean canExecute() { - if (parent == null || control == null || !parent.contains(control)) - return false; - return true; - } - - @Override - public boolean canUndo() { - if (parent == null || control == null) - return false; - return !parent.contains(control); - } - - @Override - public void execute() { - this.parent.removeChild(control); - } - - @Override - public void undo() { - this.parent.addChild(control); - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import org.eclipse.gef.commands.Command; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class DeleteCommand extends Command { + + private BControl control; + private BControl parent; + + public DeleteCommand(BControl control, BControl parent) { + this.control = control; + this.parent = parent; + } + + @Override + public boolean canExecute() { + if (parent == null || control == null || !parent.contains(control)) + return false; + return true; + } + + @Override + public boolean canUndo() { + if (parent == null || control == null) + return false; + return !parent.contains(control); + } + + @Override + public void execute() { + this.parent.removeChild(control); + } + + @Override + public void undo() { + this.parent.addChild(control); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/FitImageCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/FitImageCommand.java index 7f2b875d316e7426f97e2c3dc7cbdda17e3adb62..d82996c071f62f53831bb4115eee52b96861d574 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/FitImageCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/FitImageCommand.java @@ -1,71 +1,71 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.gef.commands.Command; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.model.BControl; - -public class FitImageCommand extends Command { - - private List<BControl> modelList = new ArrayList<BControl>(); - private Map<BControl, Rectangle> oldSizeMap = new HashMap<BControl, Rectangle>(); - private Map<BControl, Rectangle> newSizeMap = new HashMap<BControl, Rectangle>(); - - @Override - public boolean canExecute() { - return check(); - } - - @Override - public void execute() { - for (BControl control : modelList) { - oldSizeMap.put(control, control.getLayout()); - control.setLayout(newSizeMap.get(control)); - } - } - - @Override - public boolean canUndo() { - if (oldSizeMap.isEmpty()) - return false; - return check(); - } - - @Override - public void undo() { - for (BControl control : this.modelList) { - control.setLayout(oldSizeMap.get(control)); - } - } - - public void setModelList(List<BControl> modelList) { - this.modelList = modelList; - } - - public void setNewSizeMap(Map<BControl, Rectangle> newSizeMap) { - this.newSizeMap = newSizeMap; - } - - private boolean check() { - if (modelList.isEmpty() || newSizeMap.isEmpty()) - return false; - for (BControl control : modelList) { - if (!control.hasAttribute(AttributeConstants.ATTRIBUTE_IMAGE)) - return false; - } - return true; - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.gef.commands.Command; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.model.BControl; + +public class FitImageCommand extends Command { + + private List<BControl> modelList = new ArrayList<BControl>(); + private Map<BControl, Rectangle> oldSizeMap = new HashMap<BControl, Rectangle>(); + private Map<BControl, Rectangle> newSizeMap = new HashMap<BControl, Rectangle>(); + + @Override + public boolean canExecute() { + return check(); + } + + @Override + public void execute() { + for (BControl control : modelList) { + oldSizeMap.put(control, control.getLayout()); + control.setLayout(newSizeMap.get(control)); + } + } + + @Override + public boolean canUndo() { + if (oldSizeMap.isEmpty()) + return false; + return check(); + } + + @Override + public void undo() { + for (BControl control : this.modelList) { + control.setLayout(oldSizeMap.get(control)); + } + } + + public void setModelList(List<BControl> modelList) { + this.modelList = modelList; + } + + public void setNewSizeMap(Map<BControl, Rectangle> newSizeMap) { + this.newSizeMap = newSizeMap; + } + + private boolean check() { + if (modelList.isEmpty() || newSizeMap.isEmpty()) + return false; + for (BControl control : modelList) { + if (!control.hasAttribute(AttributeConstants.ATTRIBUTE_IMAGE)) + return false; + } + return true; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/PasteCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/PasteCommand.java index 6e3b670111ebf3432feb6661ddde0f22e7f9feb2..cfccef35a2edb28855bc012508a79bb24be20cea 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/PasteCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/PasteCommand.java @@ -1,109 +1,109 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; - -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.ui.actions.Clipboard; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class PasteCommand extends Command { - - private CopyPasteHelper cHelper; - - private HashMap<BControl, BControl> list = new HashMap<BControl, BControl>(); - - @Override - public boolean canExecute() { - cHelper = (CopyPasteHelper) Clipboard.getDefault().getContents(); - if (cHelper == null) - return false; - ArrayList<BControl> myList = cHelper.getList(); - if (myList.isEmpty()) - return false; - Iterator<?> it = myList.iterator(); - while (it.hasNext()) { - BControl node = (BControl) it.next(); - if (isPastableNode(node)) { - list.put(node, null); - } - } - return true; - } - - @Override - public void execute() { - if (!canExecute()) - return; - Iterator<BControl> it = list.keySet().iterator(); - while (it.hasNext()) { - BControl control = (BControl) it.next(); - try { - BControl clone = (BControl) control.clone(); - int x = Integer.valueOf(Integer.valueOf(clone - .getAttributeValue(AttributeConstants.ATTRIBUTE_X) - .toString())); - int y = Integer.valueOf(Integer.valueOf(clone - .getAttributeValue(AttributeConstants.ATTRIBUTE_Y) - .toString())); - clone.setAttributeValue(AttributeConstants.ATTRIBUTE_X, x - + cHelper.getDistance()); - clone.setAttributeValue(AttributeConstants.ATTRIBUTE_Y, y - + cHelper.getDistance()); - list.put(control, clone); - cHelper.setDistance(cHelper.getDistance() + 10); - } catch (CloneNotSupportedException e) { - e.printStackTrace(); - } - } - redo(); - } - - @Override - public void redo() { - Iterator<BControl> it = list.values().iterator(); - while (it.hasNext()) { - BControl control = it.next(); - if (isPastableNode(control)) { - control.getParent().addChild(control); - } - } - } - - @Override - public boolean canUndo() { - return !(list.isEmpty()); - } - - @Override - public void undo() { - Iterator<BControl> it = list.values().iterator(); - while (it.hasNext()) { - BControl bcontrol = it.next(); - if (isPastableNode(bcontrol)) { - bcontrol.getParent().removeChild(bcontrol); - } - } - } - - public boolean isPastableNode(BControl control) { - if (control instanceof Visualization) - return false; - return true; - } - - public HashMap<BControl, BControl> getList() { - return this.list; - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; + +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.ui.actions.Clipboard; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class PasteCommand extends Command { + + private CopyPasteHelper cHelper; + + private HashMap<BControl, BControl> list = new HashMap<BControl, BControl>(); + + @Override + public boolean canExecute() { + cHelper = (CopyPasteHelper) Clipboard.getDefault().getContents(); + if (cHelper == null) + return false; + ArrayList<BControl> myList = cHelper.getList(); + if (myList.isEmpty()) + return false; + Iterator<?> it = myList.iterator(); + while (it.hasNext()) { + BControl node = (BControl) it.next(); + if (isPastableNode(node)) { + list.put(node, null); + } + } + return true; + } + + @Override + public void execute() { + if (!canExecute()) + return; + Iterator<BControl> it = list.keySet().iterator(); + while (it.hasNext()) { + BControl control = (BControl) it.next(); + try { + BControl clone = (BControl) control.clone(); + int x = Integer.valueOf(Integer.valueOf(clone + .getAttributeValue(AttributeConstants.ATTRIBUTE_X) + .toString())); + int y = Integer.valueOf(Integer.valueOf(clone + .getAttributeValue(AttributeConstants.ATTRIBUTE_Y) + .toString())); + clone.setAttributeValue(AttributeConstants.ATTRIBUTE_X, x + + cHelper.getDistance()); + clone.setAttributeValue(AttributeConstants.ATTRIBUTE_Y, y + + cHelper.getDistance()); + list.put(control, clone); + cHelper.setDistance(cHelper.getDistance() + 10); + } catch (CloneNotSupportedException e) { + e.printStackTrace(); + } + } + redo(); + } + + @Override + public void redo() { + Iterator<BControl> it = list.values().iterator(); + while (it.hasNext()) { + BControl control = it.next(); + if (isPastableNode(control)) { + control.getParent().addChild(control); + } + } + } + + @Override + public boolean canUndo() { + return !(list.isEmpty()); + } + + @Override + public void undo() { + Iterator<BControl> it = list.values().iterator(); + while (it.hasNext()) { + BControl bcontrol = it.next(); + if (isPastableNode(bcontrol)) { + bcontrol.getParent().removeChild(bcontrol); + } + } + } + + public boolean isPastableNode(BControl control) { + if (control instanceof Visualization) + return false; + return true; + } + + public HashMap<BControl, BControl> getList() { + return this.list; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/RenameCommand.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/RenameCommand.java index 0f0ffbc055eabc3596b19b2f64f38e9ba6af52f4..717444d85ff9e468907e51d45eee00dc3ef97838 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/RenameCommand.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/command/RenameCommand.java @@ -1,61 +1,61 @@ -/** - * (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.bmotionstudio.gef.editor.command; - -import org.eclipse.gef.commands.Command; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.model.BControl; - -public class RenameCommand extends Command { - - private BControl control; - private String oldString; - private String newString; - - public void setControl(BControl control) { - this.control = control; - } - - public void setNewString(String newString) { - this.newString = newString; - } - - @Override - public boolean canExecute() { - return checkControl(); - } - - @Override - public boolean canUndo() { - if (oldString == null) - return false; - return checkControl(); - } - - private boolean checkControl() { - if (control == null || newString == null - || !control.hasAttribute(AttributeConstants.ATTRIBUTE_TEXT)) - return false; - return true; - } - - @Override - public void execute() { - this.oldString = control.getAttributeValue( - AttributeConstants.ATTRIBUTE_TEXT).toString(); - this.control.setAttributeValue(AttributeConstants.ATTRIBUTE_TEXT, - newString); - } - - @Override - public void undo() { - this.control.setAttributeValue(AttributeConstants.ATTRIBUTE_TEXT, - oldString); - } - -} +/** + * (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.bmotionstudio.gef.editor.command; + +import org.eclipse.gef.commands.Command; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.model.BControl; + +public class RenameCommand extends Command { + + private BControl control; + private String oldString; + private String newString; + + public void setControl(BControl control) { + this.control = control; + } + + public void setNewString(String newString) { + this.newString = newString; + } + + @Override + public boolean canExecute() { + return checkControl(); + } + + @Override + public boolean canUndo() { + if (oldString == null) + return false; + return checkControl(); + } + + private boolean checkControl() { + if (control == null || newString == null + || !control.hasAttribute(AttributeConstants.ATTRIBUTE_TEXT)) + return false; + return true; + } + + @Override + public void execute() { + this.oldString = control.getAttributeValue( + AttributeConstants.ATTRIBUTE_TEXT).toString(); + this.control.setAttributeValue(AttributeConstants.ATTRIBUTE_TEXT, + newString); + } + + @Override + public void undo() { + this.control.setAttributeValue(AttributeConstants.ATTRIBUTE_TEXT, + oldString); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/AttributeExpressionEdittingSupport.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/AttributeExpressionEdittingSupport.java index 0aa643cd04cd30b162e569103f997dfdbcfd658b..eac88df0edaa01f81b2a9fc5ac5ab1396e38e546 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/AttributeExpressionEdittingSupport.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/AttributeExpressionEdittingSupport.java @@ -16,7 +16,7 @@ import org.eclipse.ui.views.properties.PropertyDescriptor; import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; import de.bmotionstudio.gef.editor.model.BControl; import de.bmotionstudio.gef.editor.observer.ObserverEvalObject; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class AttributeExpressionEdittingSupport extends EditingSupport { @@ -40,7 +40,7 @@ public class AttributeExpressionEdittingSupport extends EditingSupport { @Override protected boolean canEdit(Object element) { - return WizardObserverUtil.isEditElement(getViewer()); + return BMotionWizardUtil.isEditElement(getViewer()); } @Override diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/IPopupListener.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/IPopupListener.java index b52aeba1b30c996e86ff3714963a81b661bbd015..b7464ec82ed4df967dd6aeb47ec4d0773012323b 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/IPopupListener.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/IPopupListener.java @@ -1,15 +1,15 @@ -/** - * (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.bmotionstudio.gef.editor.edit; - -public interface IPopupListener { - - public void popupOpened(); - - public void popupClosed(); - -} +/** + * (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.bmotionstudio.gef.editor.edit; + +public interface IPopupListener { + + public void popupOpened(); + + public void popupClosed(); + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/OperationValueEditingSupport.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/OperationValueEditingSupport.java index 816acdb09ceda5a99113a6c220a003ffed912504..a33391f9387d655ea9271aea61af1a210891c694 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/OperationValueEditingSupport.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/OperationValueEditingSupport.java @@ -23,7 +23,7 @@ import de.bmotionstudio.gef.editor.eventb.MachineContentObject; import de.bmotionstudio.gef.editor.eventb.MachineOperation; import de.bmotionstudio.gef.editor.model.BControl; import de.bmotionstudio.gef.editor.scheduler.PredicateOperation; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class OperationValueEditingSupport extends EditingSupport { @@ -38,7 +38,7 @@ public class OperationValueEditingSupport extends EditingSupport { @Override protected boolean canEdit(Object element) { - return WizardObserverUtil.isEditElement(getViewer()); + return BMotionWizardUtil.isEditElement(getViewer()); } @Override diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/PredicateEditingSupport.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/PredicateEditingSupport.java index 3b53eb32de944912d6ddb1126ce5a5c58564b26f..44958fce0ab5c94416c419b216363591e59dbcfc 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/PredicateEditingSupport.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/PredicateEditingSupport.java @@ -19,7 +19,7 @@ import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Shell; import de.bmotionstudio.gef.editor.model.Visualization; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; /** * @author Lukas Ladenberger @@ -57,7 +57,7 @@ public class PredicateEditingSupport extends ObservableValueEditingSupport { @Override protected boolean canEdit(Object element) { - return WizardObserverUtil.isEditElement(getViewer()); + return BMotionWizardUtil.isEditElement(getViewer()); } } diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextCellEditorLocator.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextCellEditorLocator.java index ff822972b3615762b319ee29b5eb33d936c10de9..db6448097bb0a2baf40351c365fef23f462b889d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextCellEditorLocator.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextCellEditorLocator.java @@ -1,42 +1,42 @@ -/** - * (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.bmotionstudio.gef.editor.edit; - -import org.eclipse.draw2d.IFigure; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.gef.tools.CellEditorLocator; -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.swt.widgets.Text; - -public class TextCellEditorLocator implements CellEditorLocator { - - private IFigure textField; - - public TextCellEditorLocator(IFigure textField) { - setTextField(textField); - } - - public void relocate(CellEditor celleditor) { - Text text = (Text) celleditor.getControl(); - Rectangle rect = textField.getClientArea(); - textField.translateToAbsolute(rect); - org.eclipse.swt.graphics.Rectangle trim = text.computeTrim(0, 0, 0, 0); - rect.translate(trim.x, trim.y); - rect.width += trim.width; - rect.height += trim.height; - text.setBounds(rect.x, rect.y, rect.width, rect.height); - } - - protected IFigure getTextField() { - return textField; - } - - protected void setTextField(IFigure textField) { - this.textField = textField; - } - +/** + * (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.bmotionstudio.gef.editor.edit; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.gef.tools.CellEditorLocator; +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.swt.widgets.Text; + +public class TextCellEditorLocator implements CellEditorLocator { + + private IFigure textField; + + public TextCellEditorLocator(IFigure textField) { + setTextField(textField); + } + + public void relocate(CellEditor celleditor) { + Text text = (Text) celleditor.getControl(); + Rectangle rect = textField.getClientArea(); + textField.translateToAbsolute(rect); + org.eclipse.swt.graphics.Rectangle trim = text.computeTrim(0, 0, 0, 0); + rect.translate(trim.x, trim.y); + rect.width += trim.width; + rect.height += trim.height; + text.setBounds(rect.x, rect.y, rect.width, rect.height); + } + + protected IFigure getTextField() { + return textField; + } + + protected void setTextField(IFigure textField) { + this.textField = textField; + } + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditManager.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditManager.java index 0cf46e1173cd1ad8eea0498f3cc4a728ca1efdc8..82065ecd1d75b43fcbabbcef511437de882d9256 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditManager.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditManager.java @@ -1,156 +1,156 @@ -/** - * (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.bmotionstudio.gef.editor.edit; - -import org.eclipse.draw2d.IFigure; -import org.eclipse.gef.editparts.ZoomListener; -import org.eclipse.gef.editparts.ZoomManager; -import org.eclipse.gef.tools.CellEditorLocator; -import org.eclipse.gef.tools.DirectEditManager; -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.jface.viewers.TextCellEditor; -import org.eclipse.swt.SWT; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Text; -import org.eclipse.ui.IActionBars; -import org.eclipse.ui.PlatformUI; -import org.eclipse.ui.actions.ActionFactory; -import org.eclipse.ui.part.CellEditorActionHandler; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; - -public class TextEditManager extends DirectEditManager { - - private IActionBars actionBars; - private CellEditorActionHandler actionHandler; - private IAction copy, cut, paste, undo, redo, find, selectAll, delete; - private double cachedZoom = -1.0; - private Font scaledFont; - private ZoomListener zoomListener = new ZoomListener() { - public void zoomChanged(double newZoom) { - updateScaledFont(newZoom); - } - }; - - public TextEditManager(AppAbstractEditPart source, CellEditorLocator locator) { - super(source, null, locator); - } - - /** - * @see org.eclipse.gef.tools.DirectEditManager#bringDown() - */ - protected void bringDown() { - ZoomManager zoomMgr = (ZoomManager) getEditPart().getViewer() - .getProperty(ZoomManager.class.toString()); - if (zoomMgr != null) - zoomMgr.removeZoomListener(zoomListener); - - if (actionHandler != null) { - actionHandler.dispose(); - actionHandler = null; - } - if (actionBars != null) { - restoreSavedActions(actionBars); - actionBars.updateActionBars(); - actionBars = null; - } - - super.bringDown(); - // dispose any scaled fonts that might have been created - disposeScaledFont(); - } - - protected CellEditor createCellEditorOn(Composite composite) { - return new TextCellEditor(composite, SWT.NONE); - } - - private void disposeScaledFont() { - if (scaledFont != null) { - scaledFont.dispose(); - scaledFont = null; - } - } - - protected void initCellEditor() { - // update text - IFigure figure = (IFigure) getEditPart().getFigure(); - getCellEditor().setValue( - ((BControl) getEditPart().getModel()) - .getAttributeValue(AttributeConstants.ATTRIBUTE_TEXT)); - // update font - ZoomManager zoomMgr = (ZoomManager) getEditPart().getViewer() - .getProperty(ZoomManager.class.toString()); - if (zoomMgr != null) { - // this will force the font to be set - cachedZoom = -1.0; - updateScaledFont(zoomMgr.getZoom()); - zoomMgr.addZoomListener(zoomListener); - } else { - getCellEditor().getControl().setFont(figure.getFont()); - } - - // Hook the cell editor's copy/paste actions to the actionBars so that - // they can - // be invoked via keyboard shortcuts. - actionBars = PlatformUI.getWorkbench().getActiveWorkbenchWindow() - .getActivePage().getActiveEditor().getEditorSite() - .getActionBars(); - saveCurrentActions(actionBars); - actionHandler = new CellEditorActionHandler(actionBars); - actionHandler.addCellEditor(getCellEditor()); - actionBars.updateActionBars(); - } - - private void restoreSavedActions(IActionBars actionBars) { - actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(), copy); - actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(), paste); - actionBars.setGlobalActionHandler(ActionFactory.DELETE.getId(), delete); - actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), - selectAll); - actionBars.setGlobalActionHandler(ActionFactory.CUT.getId(), cut); - actionBars.setGlobalActionHandler(ActionFactory.FIND.getId(), find); - actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undo); - actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(), redo); - } - - private void saveCurrentActions(IActionBars actionBars) { - copy = actionBars.getGlobalActionHandler(ActionFactory.COPY.getId()); - paste = actionBars.getGlobalActionHandler(ActionFactory.PASTE.getId()); - delete = actionBars - .getGlobalActionHandler(ActionFactory.DELETE.getId()); - selectAll = actionBars.getGlobalActionHandler(ActionFactory.SELECT_ALL - .getId()); - cut = actionBars.getGlobalActionHandler(ActionFactory.CUT.getId()); - find = actionBars.getGlobalActionHandler(ActionFactory.FIND.getId()); - undo = actionBars.getGlobalActionHandler(ActionFactory.UNDO.getId()); - redo = actionBars.getGlobalActionHandler(ActionFactory.REDO.getId()); - } - - private void updateScaledFont(double zoom) { - if (cachedZoom == zoom) - return; - - Text text = (Text) getCellEditor().getControl(); - Font font = getEditPart().getFigure().getFont(); - - disposeScaledFont(); - cachedZoom = zoom; - if (zoom == 1.0) - text.setFont(font); - else { - FontData fd = font.getFontData()[0]; - fd.setHeight((int) (fd.getHeight() * zoom)); - text.setFont(scaledFont = new Font(null, fd)); - } - } - +/** + * (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.bmotionstudio.gef.editor.edit; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.gef.editparts.ZoomListener; +import org.eclipse.gef.editparts.ZoomManager; +import org.eclipse.gef.tools.CellEditorLocator; +import org.eclipse.gef.tools.DirectEditManager; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.TextCellEditor; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Text; +import org.eclipse.ui.IActionBars; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.actions.ActionFactory; +import org.eclipse.ui.part.CellEditorActionHandler; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; + +public class TextEditManager extends DirectEditManager { + + private IActionBars actionBars; + private CellEditorActionHandler actionHandler; + private IAction copy, cut, paste, undo, redo, find, selectAll, delete; + private double cachedZoom = -1.0; + private Font scaledFont; + private ZoomListener zoomListener = new ZoomListener() { + public void zoomChanged(double newZoom) { + updateScaledFont(newZoom); + } + }; + + public TextEditManager(AppAbstractEditPart source, CellEditorLocator locator) { + super(source, null, locator); + } + + /** + * @see org.eclipse.gef.tools.DirectEditManager#bringDown() + */ + protected void bringDown() { + ZoomManager zoomMgr = (ZoomManager) getEditPart().getViewer() + .getProperty(ZoomManager.class.toString()); + if (zoomMgr != null) + zoomMgr.removeZoomListener(zoomListener); + + if (actionHandler != null) { + actionHandler.dispose(); + actionHandler = null; + } + if (actionBars != null) { + restoreSavedActions(actionBars); + actionBars.updateActionBars(); + actionBars = null; + } + + super.bringDown(); + // dispose any scaled fonts that might have been created + disposeScaledFont(); + } + + protected CellEditor createCellEditorOn(Composite composite) { + return new TextCellEditor(composite, SWT.NONE); + } + + private void disposeScaledFont() { + if (scaledFont != null) { + scaledFont.dispose(); + scaledFont = null; + } + } + + protected void initCellEditor() { + // update text + IFigure figure = (IFigure) getEditPart().getFigure(); + getCellEditor().setValue( + ((BControl) getEditPart().getModel()) + .getAttributeValue(AttributeConstants.ATTRIBUTE_TEXT)); + // update font + ZoomManager zoomMgr = (ZoomManager) getEditPart().getViewer() + .getProperty(ZoomManager.class.toString()); + if (zoomMgr != null) { + // this will force the font to be set + cachedZoom = -1.0; + updateScaledFont(zoomMgr.getZoom()); + zoomMgr.addZoomListener(zoomListener); + } else { + getCellEditor().getControl().setFont(figure.getFont()); + } + + // Hook the cell editor's copy/paste actions to the actionBars so that + // they can + // be invoked via keyboard shortcuts. + actionBars = PlatformUI.getWorkbench().getActiveWorkbenchWindow() + .getActivePage().getActiveEditor().getEditorSite() + .getActionBars(); + saveCurrentActions(actionBars); + actionHandler = new CellEditorActionHandler(actionBars); + actionHandler.addCellEditor(getCellEditor()); + actionBars.updateActionBars(); + } + + private void restoreSavedActions(IActionBars actionBars) { + actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(), copy); + actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(), paste); + actionBars.setGlobalActionHandler(ActionFactory.DELETE.getId(), delete); + actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), + selectAll); + actionBars.setGlobalActionHandler(ActionFactory.CUT.getId(), cut); + actionBars.setGlobalActionHandler(ActionFactory.FIND.getId(), find); + actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(), undo); + actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(), redo); + } + + private void saveCurrentActions(IActionBars actionBars) { + copy = actionBars.getGlobalActionHandler(ActionFactory.COPY.getId()); + paste = actionBars.getGlobalActionHandler(ActionFactory.PASTE.getId()); + delete = actionBars + .getGlobalActionHandler(ActionFactory.DELETE.getId()); + selectAll = actionBars.getGlobalActionHandler(ActionFactory.SELECT_ALL + .getId()); + cut = actionBars.getGlobalActionHandler(ActionFactory.CUT.getId()); + find = actionBars.getGlobalActionHandler(ActionFactory.FIND.getId()); + undo = actionBars.getGlobalActionHandler(ActionFactory.UNDO.getId()); + redo = actionBars.getGlobalActionHandler(ActionFactory.REDO.getId()); + } + + private void updateScaledFont(double zoom) { + if (cachedZoom == zoom) + return; + + Text text = (Text) getCellEditor().getControl(); + Font font = getEditPart().getFigure().getFont(); + + disposeScaledFont(); + cachedZoom = zoom; + if (zoom == 1.0) + text.setFont(font); + else { + FontData fd = font.getFontData()[0]; + fd.setHeight((int) (fd.getHeight() * zoom)); + text.setFont(scaledFont = new Font(null, fd)); + } + } + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditingSupport.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditingSupport.java index 95e727432e153ed36112c58c3709b84e2d57f98d..bc01452ea8c5b2d1006d62fa7398b0ad02b67445 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditingSupport.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/edit/TextEditingSupport.java @@ -18,7 +18,7 @@ import org.eclipse.jface.viewers.ViewerCell; import org.eclipse.swt.SWT; import org.eclipse.swt.widgets.Composite; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class TextEditingSupport extends ObservableValueEditingSupport { @@ -54,7 +54,7 @@ public class TextEditingSupport extends ObservableValueEditingSupport { @Override protected boolean canEdit(Object element) { - return WizardObserverUtil.isEditElement(getViewer()); + return BMotionWizardUtil.isEditElement(getViewer()); } } diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppDeletePolicy.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppDeletePolicy.java index 05cdf766042d0c2428057ed1b90aacc4fbfdd74d..e6e18db463743f48589a4b97253412a7328a0084 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppDeletePolicy.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppDeletePolicy.java @@ -1,24 +1,24 @@ -/** - * (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.bmotionstudio.gef.editor.editpolicy; - -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.editpolicies.ComponentEditPolicy; -import org.eclipse.gef.requests.GroupRequest; - -import de.bmotionstudio.gef.editor.command.DeleteCommand; -import de.bmotionstudio.gef.editor.model.BControl; - -public class AppDeletePolicy extends ComponentEditPolicy { - - protected Command createDeleteCommand(GroupRequest deleteRequest) { - DeleteCommand command = new DeleteCommand((BControl) getHost() - .getModel(), (BControl) getHost().getParent().getModel()); - return command; - } - -} +/** + * (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.bmotionstudio.gef.editor.editpolicy; + +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.editpolicies.ComponentEditPolicy; +import org.eclipse.gef.requests.GroupRequest; + +import de.bmotionstudio.gef.editor.command.DeleteCommand; +import de.bmotionstudio.gef.editor.model.BControl; + +public class AppDeletePolicy extends ComponentEditPolicy { + + protected Command createDeleteCommand(GroupRequest deleteRequest) { + DeleteCommand command = new DeleteCommand((BControl) getHost() + .getModel(), (BControl) getHost().getParent().getModel()); + return command; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppEditLayoutPolicy.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppEditLayoutPolicy.java index 6d8080f8a487911ec7ae0e5888adccb572e17898..b379e570073f87abde193bdb8a720239ded78f9f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppEditLayoutPolicy.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/AppEditLayoutPolicy.java @@ -1,233 +1,233 @@ -/** - * (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.bmotionstudio.gef.editor.editpolicy; - -import org.eclipse.draw2d.PositionConstants; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.gef.EditPart; -import org.eclipse.gef.EditPolicy; -import org.eclipse.gef.Request; -import org.eclipse.gef.SnapToGuides; -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.editpolicies.ResizableEditPolicy; -import org.eclipse.gef.editpolicies.XYLayoutEditPolicy; -import org.eclipse.gef.requests.ChangeBoundsRequest; -import org.eclipse.gef.requests.CreateRequest; -import org.eclipse.gef.rulers.RulerProvider; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.attribute.BAttributeHeight; -import de.bmotionstudio.gef.editor.attribute.BAttributeWidth; -import de.bmotionstudio.gef.editor.command.BControlChangeLayoutCommand; -import de.bmotionstudio.gef.editor.command.CreateCommand; -import de.bmotionstudio.gef.editor.command.ChangeGuideCommand; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.BMotionGuide; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; - -public class AppEditLayoutPolicy extends XYLayoutEditPolicy { - - @Override - protected Command createChangeConstraintCommand(EditPart child, - Object constraint) { - return null; - } - - @Override - protected Command createChangeConstraintCommand( - ChangeBoundsRequest request, EditPart child, Object constraint) { - - BControlChangeLayoutCommand cmd = new BControlChangeLayoutCommand(); - BControl part = (BControl) child.getModel(); - cmd.setModel(child.getModel()); - cmd.setConstraint((Rectangle) constraint); - Command result = cmd; - - if ((request.getResizeDirection() & PositionConstants.NORTH_SOUTH) != 0) { - Integer guidePos = (Integer) request.getExtendedData().get( - SnapToGuides.KEY_HORIZONTAL_GUIDE); - if (guidePos != null) { - result = chainGuideAttachmentCommand(request, part, result, - true); - } else if (part.getHorizontalGuide() != null) { - // SnapToGuides didn't provide a horizontal guide, but this part - // is attached - // to a horizontal guide. Now we check to see if the part is - // attached to - // the guide along the edge being resized. If that is the case, - // we need to - // detach the part from the guide; otherwise, we leave it alone. - int alignment = part.getHorizontalGuide().getAlignment(part); - int edgeBeingResized = 0; - if ((request.getResizeDirection() & PositionConstants.NORTH) != 0) - edgeBeingResized = -1; - else - edgeBeingResized = 1; - if (alignment == edgeBeingResized) - result = result.chain(new ChangeGuideCommand(part, true)); - } - } - - if ((request.getResizeDirection() & PositionConstants.EAST_WEST) != 0) { - Integer guidePos = (Integer) request.getExtendedData().get( - SnapToGuides.KEY_VERTICAL_GUIDE); - if (guidePos != null) { - result = chainGuideAttachmentCommand(request, part, result, - false); - } else if (part.getVerticalGuide() != null) { - int alignment = part.getVerticalGuide().getAlignment(part); - int edgeBeingResized = 0; - if ((request.getResizeDirection() & PositionConstants.WEST) != 0) - edgeBeingResized = -1; - else - edgeBeingResized = 1; - if (alignment == edgeBeingResized) - result = result.chain(new ChangeGuideCommand(part, false)); - } - } - - if (request.getType().equals(REQ_MOVE_CHILDREN) - || request.getType().equals(REQ_ALIGN_CHILDREN)) { - result = chainGuideAttachmentCommand(request, part, result, true); - result = chainGuideAttachmentCommand(request, part, result, false); - result = chainGuideDetachmentCommand(request, part, result, true); - result = chainGuideDetachmentCommand(request, part, result, false); - } - - return result; - } - - @Override - protected EditPolicy createChildEditPolicy(EditPart child) { - - BControl control = (BControl) child.getModel(); - - ResizableEditPolicy policy = new ResizableEditPolicy(); - - BAttributeWidth atrWidth = (BAttributeWidth) control.getAttributes() - .get(AttributeConstants.ATTRIBUTE_WIDTH); - BAttributeHeight atrHeight = (BAttributeHeight) control.getAttributes() - .get(AttributeConstants.ATTRIBUTE_HEIGHT); - - if (atrWidth.isEditable() && atrHeight.isEditable()) - return policy; - - if (atrWidth.isEditable()) { - policy.setResizeDirections(PositionConstants.EAST_WEST); - return policy; - } - - if (atrHeight.isEditable()) { - policy.setResizeDirections(PositionConstants.NORTH_SOUTH); - return policy; - } - - policy.setResizeDirections(0); - - return policy; - - } - - @Override - protected Command getCreateCommand(CreateRequest request) { - - if (request.getType() == REQ_CREATE - && getHost() instanceof AppAbstractEditPart) { - - if (((BControl) ((AppAbstractEditPart) getHost()).getModel()) - .canHaveChildren()) { - - BControl newObj = (BControl) request.getNewObject(); - - CreateCommand createCmd = new CreateCommand( - newObj, (BControl) getHost().getModel()); - - Rectangle constraint = (Rectangle) getConstraintFor(request); - constraint.x = (constraint.x < 0) ? 0 : constraint.x; - constraint.y = (constraint.y < 0) ? 0 : constraint.y; - - BAttributeWidth atrWidth = (BAttributeWidth) newObj - .getAttributes() - .get(AttributeConstants.ATTRIBUTE_WIDTH); - BAttributeHeight atrHeight = (BAttributeHeight) newObj - .getAttributes().get( - AttributeConstants.ATTRIBUTE_HEIGHT); - - if (atrWidth != null) { - constraint.width = Integer.valueOf(atrWidth.getValue() - .toString()); - } else { - constraint.width = (constraint.width <= 0) ? 100 - : constraint.width; - } - - if (atrHeight != null) { - constraint.height = Integer.valueOf(atrHeight.getValue() - .toString()); - } else { - constraint.height = (constraint.height <= 0) ? 100 - : constraint.height; - } - - createCmd.setLayout(constraint); - - Command cmd = chainGuideAttachmentCommand(request, newObj, - createCmd, true); - return chainGuideAttachmentCommand(request, newObj, cmd, false); - - } - - } - - return null; - - } - - protected Command chainGuideAttachmentCommand(Request request, - BControl part, Command cmd, boolean horizontal) { - Command result = cmd; - - // Attach to guide, if one is given - Integer guidePos = (Integer) request.getExtendedData().get( - horizontal ? SnapToGuides.KEY_HORIZONTAL_GUIDE - : SnapToGuides.KEY_VERTICAL_GUIDE); - if (guidePos != null) { - int alignment = ((Integer) request.getExtendedData().get( - horizontal ? SnapToGuides.KEY_HORIZONTAL_ANCHOR - : SnapToGuides.KEY_VERTICAL_ANCHOR)).intValue(); - ChangeGuideCommand cgm = new ChangeGuideCommand(part, horizontal); - cgm.setNewGuide(findGuideAt(guidePos.intValue(), horizontal), - alignment); - result = result.chain(cgm); - } - - return result; - } - - protected Command chainGuideDetachmentCommand(Request request, - BControl part, Command cmd, boolean horizontal) { - Command result = cmd; - - // Detach from guide, if none is given - Integer guidePos = (Integer) request.getExtendedData().get( - horizontal ? SnapToGuides.KEY_HORIZONTAL_GUIDE - : SnapToGuides.KEY_VERTICAL_GUIDE); - if (guidePos == null) - result = result.chain(new ChangeGuideCommand(part, horizontal)); - - return result; - } - - protected BMotionGuide findGuideAt(int pos, boolean horizontal) { - RulerProvider provider = ((RulerProvider) getHost().getViewer() - .getProperty( - horizontal ? RulerProvider.PROPERTY_VERTICAL_RULER - : RulerProvider.PROPERTY_HORIZONTAL_RULER)); - return (BMotionGuide) provider.getGuideAt(pos); - } - -} +/** + * (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.bmotionstudio.gef.editor.editpolicy; + +import org.eclipse.draw2d.PositionConstants; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.Request; +import org.eclipse.gef.SnapToGuides; +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.editpolicies.ResizableEditPolicy; +import org.eclipse.gef.editpolicies.XYLayoutEditPolicy; +import org.eclipse.gef.requests.ChangeBoundsRequest; +import org.eclipse.gef.requests.CreateRequest; +import org.eclipse.gef.rulers.RulerProvider; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.attribute.BAttributeHeight; +import de.bmotionstudio.gef.editor.attribute.BAttributeWidth; +import de.bmotionstudio.gef.editor.command.BControlChangeLayoutCommand; +import de.bmotionstudio.gef.editor.command.CreateCommand; +import de.bmotionstudio.gef.editor.command.ChangeGuideCommand; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.BMotionGuide; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; + +public class AppEditLayoutPolicy extends XYLayoutEditPolicy { + + @Override + protected Command createChangeConstraintCommand(EditPart child, + Object constraint) { + return null; + } + + @Override + protected Command createChangeConstraintCommand( + ChangeBoundsRequest request, EditPart child, Object constraint) { + + BControlChangeLayoutCommand cmd = new BControlChangeLayoutCommand(); + BControl part = (BControl) child.getModel(); + cmd.setModel(child.getModel()); + cmd.setConstraint((Rectangle) constraint); + Command result = cmd; + + if ((request.getResizeDirection() & PositionConstants.NORTH_SOUTH) != 0) { + Integer guidePos = (Integer) request.getExtendedData().get( + SnapToGuides.KEY_HORIZONTAL_GUIDE); + if (guidePos != null) { + result = chainGuideAttachmentCommand(request, part, result, + true); + } else if (part.getHorizontalGuide() != null) { + // SnapToGuides didn't provide a horizontal guide, but this part + // is attached + // to a horizontal guide. Now we check to see if the part is + // attached to + // the guide along the edge being resized. If that is the case, + // we need to + // detach the part from the guide; otherwise, we leave it alone. + int alignment = part.getHorizontalGuide().getAlignment(part); + int edgeBeingResized = 0; + if ((request.getResizeDirection() & PositionConstants.NORTH) != 0) + edgeBeingResized = -1; + else + edgeBeingResized = 1; + if (alignment == edgeBeingResized) + result = result.chain(new ChangeGuideCommand(part, true)); + } + } + + if ((request.getResizeDirection() & PositionConstants.EAST_WEST) != 0) { + Integer guidePos = (Integer) request.getExtendedData().get( + SnapToGuides.KEY_VERTICAL_GUIDE); + if (guidePos != null) { + result = chainGuideAttachmentCommand(request, part, result, + false); + } else if (part.getVerticalGuide() != null) { + int alignment = part.getVerticalGuide().getAlignment(part); + int edgeBeingResized = 0; + if ((request.getResizeDirection() & PositionConstants.WEST) != 0) + edgeBeingResized = -1; + else + edgeBeingResized = 1; + if (alignment == edgeBeingResized) + result = result.chain(new ChangeGuideCommand(part, false)); + } + } + + if (request.getType().equals(REQ_MOVE_CHILDREN) + || request.getType().equals(REQ_ALIGN_CHILDREN)) { + result = chainGuideAttachmentCommand(request, part, result, true); + result = chainGuideAttachmentCommand(request, part, result, false); + result = chainGuideDetachmentCommand(request, part, result, true); + result = chainGuideDetachmentCommand(request, part, result, false); + } + + return result; + } + + @Override + protected EditPolicy createChildEditPolicy(EditPart child) { + + BControl control = (BControl) child.getModel(); + + ResizableEditPolicy policy = new ResizableEditPolicy(); + + BAttributeWidth atrWidth = (BAttributeWidth) control.getAttributes() + .get(AttributeConstants.ATTRIBUTE_WIDTH); + BAttributeHeight atrHeight = (BAttributeHeight) control.getAttributes() + .get(AttributeConstants.ATTRIBUTE_HEIGHT); + + if (atrWidth.isEditable() && atrHeight.isEditable()) + return policy; + + if (atrWidth.isEditable()) { + policy.setResizeDirections(PositionConstants.EAST_WEST); + return policy; + } + + if (atrHeight.isEditable()) { + policy.setResizeDirections(PositionConstants.NORTH_SOUTH); + return policy; + } + + policy.setResizeDirections(0); + + return policy; + + } + + @Override + protected Command getCreateCommand(CreateRequest request) { + + if (request.getType() == REQ_CREATE + && getHost() instanceof AppAbstractEditPart) { + + if (((BControl) ((AppAbstractEditPart) getHost()).getModel()) + .canHaveChildren()) { + + BControl newObj = (BControl) request.getNewObject(); + + CreateCommand createCmd = new CreateCommand( + newObj, (BControl) getHost().getModel()); + + Rectangle constraint = (Rectangle) getConstraintFor(request); + constraint.x = (constraint.x < 0) ? 0 : constraint.x; + constraint.y = (constraint.y < 0) ? 0 : constraint.y; + + BAttributeWidth atrWidth = (BAttributeWidth) newObj + .getAttributes() + .get(AttributeConstants.ATTRIBUTE_WIDTH); + BAttributeHeight atrHeight = (BAttributeHeight) newObj + .getAttributes().get( + AttributeConstants.ATTRIBUTE_HEIGHT); + + if (atrWidth != null) { + constraint.width = Integer.valueOf(atrWidth.getValue() + .toString()); + } else { + constraint.width = (constraint.width <= 0) ? 100 + : constraint.width; + } + + if (atrHeight != null) { + constraint.height = Integer.valueOf(atrHeight.getValue() + .toString()); + } else { + constraint.height = (constraint.height <= 0) ? 100 + : constraint.height; + } + + createCmd.setLayout(constraint); + + Command cmd = chainGuideAttachmentCommand(request, newObj, + createCmd, true); + return chainGuideAttachmentCommand(request, newObj, cmd, false); + + } + + } + + return null; + + } + + protected Command chainGuideAttachmentCommand(Request request, + BControl part, Command cmd, boolean horizontal) { + Command result = cmd; + + // Attach to guide, if one is given + Integer guidePos = (Integer) request.getExtendedData().get( + horizontal ? SnapToGuides.KEY_HORIZONTAL_GUIDE + : SnapToGuides.KEY_VERTICAL_GUIDE); + if (guidePos != null) { + int alignment = ((Integer) request.getExtendedData().get( + horizontal ? SnapToGuides.KEY_HORIZONTAL_ANCHOR + : SnapToGuides.KEY_VERTICAL_ANCHOR)).intValue(); + ChangeGuideCommand cgm = new ChangeGuideCommand(part, horizontal); + cgm.setNewGuide(findGuideAt(guidePos.intValue(), horizontal), + alignment); + result = result.chain(cgm); + } + + return result; + } + + protected Command chainGuideDetachmentCommand(Request request, + BControl part, Command cmd, boolean horizontal) { + Command result = cmd; + + // Detach from guide, if none is given + Integer guidePos = (Integer) request.getExtendedData().get( + horizontal ? SnapToGuides.KEY_HORIZONTAL_GUIDE + : SnapToGuides.KEY_VERTICAL_GUIDE); + if (guidePos == null) + result = result.chain(new ChangeGuideCommand(part, horizontal)); + + return result; + } + + protected BMotionGuide findGuideAt(int pos, boolean horizontal) { + RulerProvider provider = ((RulerProvider) getHost().getViewer() + .getProperty( + horizontal ? RulerProvider.PROPERTY_VERTICAL_RULER + : RulerProvider.PROPERTY_HORIZONTAL_RULER)); + return (BMotionGuide) provider.getGuideAt(pos); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/BMotionNodeEditPolicy.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/BMotionNodeEditPolicy.java index eceaa531a7c6b1803f0af7d91b8359121dba944c..71e68f16775c4bd77a02435070de5179d75e7607 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/BMotionNodeEditPolicy.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/BMotionNodeEditPolicy.java @@ -1,85 +1,85 @@ -/** - * (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.bmotionstudio.gef.editor.editpolicy; - -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy; -import org.eclipse.gef.requests.CreateConnectionRequest; -import org.eclipse.gef.requests.ReconnectRequest; - -import de.bmotionstudio.gef.editor.command.ConnectionCreateCommand; -import de.bmotionstudio.gef.editor.command.ConnectionReconnectCommand; -import de.bmotionstudio.gef.editor.model.BConnection; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BMotionNodeEditPolicy extends GraphicalNodeEditPolicy { - - /* - * (non-Javadoc) - * - * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# - * getConnectionCompleteCommand - * (org.eclipse.gef.requests.CreateConnectionRequest) - */ - protected Command getConnectionCompleteCommand( - CreateConnectionRequest request) { - ConnectionCreateCommand cmd = (ConnectionCreateCommand) request - .getStartCommand(); - cmd.setTarget((BControl) getHost().getModel()); - return cmd; - } - - /* - * (non-Javadoc) - * - * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# - * getConnectionCreateCommand - * (org.eclipse.gef.requests.CreateConnectionRequest) - */ - protected Command getConnectionCreateCommand(CreateConnectionRequest request) { - BControl source = (BControl) getHost().getModel(); - ConnectionCreateCommand cmd = new ConnectionCreateCommand(source); - BConnection con = (BConnection) request.getNewObject(); - con.setVisualization(source.getVisualization()); - cmd.setConnection(con); - request.setStartCommand(cmd); - return cmd; - } - - /* - * (non-Javadoc) - * - * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# - * getReconnectSourceCommand (org.eclipse.gef.requests.ReconnectRequest) - */ - protected Command getReconnectSourceCommand(ReconnectRequest request) { - BConnection conn = (BConnection) request.getConnectionEditPart() - .getModel(); - BControl newSource = (BControl) getHost().getModel(); - ConnectionReconnectCommand cmd = new ConnectionReconnectCommand(); - cmd.setNewSource(newSource); - cmd.setConnection(conn); - return cmd; - } - - /* - * (non-Javadoc) - * - * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# - * getReconnectTargetCommand (org.eclipse.gef.requests.ReconnectRequest) - */ - protected Command getReconnectTargetCommand(ReconnectRequest request) { - BConnection conn = (BConnection) request.getConnectionEditPart() - .getModel(); - BControl newTarget = (BControl) getHost().getModel(); - ConnectionReconnectCommand cmd = new ConnectionReconnectCommand(); - cmd.setNewTarget(newTarget); - cmd.setConnection(conn); - return cmd; - } - -} +/** + * (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.bmotionstudio.gef.editor.editpolicy; + +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy; +import org.eclipse.gef.requests.CreateConnectionRequest; +import org.eclipse.gef.requests.ReconnectRequest; + +import de.bmotionstudio.gef.editor.command.ConnectionCreateCommand; +import de.bmotionstudio.gef.editor.command.ConnectionReconnectCommand; +import de.bmotionstudio.gef.editor.model.BConnection; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BMotionNodeEditPolicy extends GraphicalNodeEditPolicy { + + /* + * (non-Javadoc) + * + * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# + * getConnectionCompleteCommand + * (org.eclipse.gef.requests.CreateConnectionRequest) + */ + protected Command getConnectionCompleteCommand( + CreateConnectionRequest request) { + ConnectionCreateCommand cmd = (ConnectionCreateCommand) request + .getStartCommand(); + cmd.setTarget((BControl) getHost().getModel()); + return cmd; + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# + * getConnectionCreateCommand + * (org.eclipse.gef.requests.CreateConnectionRequest) + */ + protected Command getConnectionCreateCommand(CreateConnectionRequest request) { + BControl source = (BControl) getHost().getModel(); + ConnectionCreateCommand cmd = new ConnectionCreateCommand(source); + BConnection con = (BConnection) request.getNewObject(); + con.setVisualization(source.getVisualization()); + cmd.setConnection(con); + request.setStartCommand(cmd); + return cmd; + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# + * getReconnectSourceCommand (org.eclipse.gef.requests.ReconnectRequest) + */ + protected Command getReconnectSourceCommand(ReconnectRequest request) { + BConnection conn = (BConnection) request.getConnectionEditPart() + .getModel(); + BControl newSource = (BControl) getHost().getModel(); + ConnectionReconnectCommand cmd = new ConnectionReconnectCommand(); + cmd.setNewSource(newSource); + cmd.setConnection(conn); + return cmd; + } + + /* + * (non-Javadoc) + * + * @see org.eclipse.gef.editpolicies.GraphicalNodeEditPolicy# + * getReconnectTargetCommand (org.eclipse.gef.requests.ReconnectRequest) + */ + protected Command getReconnectTargetCommand(ReconnectRequest request) { + BConnection conn = (BConnection) request.getConnectionEditPart() + .getModel(); + BControl newTarget = (BControl) getHost().getModel(); + ConnectionReconnectCommand cmd = new ConnectionReconnectCommand(); + cmd.setNewTarget(newTarget); + cmd.setConnection(conn); + return cmd; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/CustomDirectEditPolicy.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/CustomDirectEditPolicy.java index c653ae10b5395880bc01730652e9933ef04765eb..0676c50ab47bd98a5fd9a44c929bf0e7de2dc97c 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/CustomDirectEditPolicy.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/CustomDirectEditPolicy.java @@ -1,39 +1,39 @@ -/** - * (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.bmotionstudio.gef.editor.editpolicy; - -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.editpolicies.DirectEditPolicy; -import org.eclipse.gef.requests.DirectEditRequest; - -import de.bmotionstudio.gef.editor.command.RenameCommand; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; - -public class CustomDirectEditPolicy extends DirectEditPolicy { - - /** - * @see CustomDirectEditPolicy#getDirectEditCommand(DirectEditRequest) - */ - protected Command getDirectEditCommand(DirectEditRequest edit) { - String labelText = (String) edit.getCellEditor().getValue(); - AppAbstractEditPart label = (AppAbstractEditPart) getHost(); - RenameCommand command = new RenameCommand(); - command.setControl((BControl) label.getModel()); - command.setNewString(labelText); - return command; - } - - /** - * @see CustomDirectEditPolicy#showCurrentEditValue(DirectEditRequest) - */ - protected void showCurrentEditValue(DirectEditRequest request) { - // String value = (String) request.getCellEditor().getValue(); - getHostFigure().getUpdateManager().performUpdate(); - } - -} +/** + * (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.bmotionstudio.gef.editor.editpolicy; + +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.editpolicies.DirectEditPolicy; +import org.eclipse.gef.requests.DirectEditRequest; + +import de.bmotionstudio.gef.editor.command.RenameCommand; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.part.AppAbstractEditPart; + +public class CustomDirectEditPolicy extends DirectEditPolicy { + + /** + * @see CustomDirectEditPolicy#getDirectEditCommand(DirectEditRequest) + */ + protected Command getDirectEditCommand(DirectEditRequest edit) { + String labelText = (String) edit.getCellEditor().getValue(); + AppAbstractEditPart label = (AppAbstractEditPart) getHost(); + RenameCommand command = new RenameCommand(); + command.setControl((BControl) label.getModel()); + command.setNewString(labelText); + return command; + } + + /** + * @see CustomDirectEditPolicy#showCurrentEditValue(DirectEditRequest) + */ + protected void showCurrentEditValue(DirectEditRequest request) { + // String value = (String) request.getCellEditor().getValue(); + getHostFigure().getUpdateManager().performUpdate(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/RenamePolicy.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/RenamePolicy.java index 3d555a6708d99ab15db3c1ab83d02026af54cd34..831e24d56d4a10548c69bdcfd4d44202a68c0753 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/RenamePolicy.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/editpolicy/RenamePolicy.java @@ -1,33 +1,33 @@ -/** - * (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.bmotionstudio.gef.editor.editpolicy; - -import org.eclipse.gef.Request; -import org.eclipse.gef.commands.Command; -import org.eclipse.gef.editpolicies.AbstractEditPolicy; - -import de.bmotionstudio.gef.editor.command.RenameCommand; -import de.bmotionstudio.gef.editor.model.BControl; - -public class RenamePolicy extends AbstractEditPolicy { - - @Override - public Command getCommand(Request request) { - if (request.getType().equals("rename")) - return createRenameCommand(request); - return null; - } - - protected Command createRenameCommand(Request renameRequest) { - RenameCommand command = new RenameCommand(); - command.setControl(((BControl) getHost().getModel())); - command.setNewString(((String) renameRequest.getExtendedData().get( - "newName"))); - return command; - } - -} +/** + * (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.bmotionstudio.gef.editor.editpolicy; + +import org.eclipse.gef.Request; +import org.eclipse.gef.commands.Command; +import org.eclipse.gef.editpolicies.AbstractEditPolicy; + +import de.bmotionstudio.gef.editor.command.RenameCommand; +import de.bmotionstudio.gef.editor.model.BControl; + +public class RenamePolicy extends AbstractEditPolicy { + + @Override + public Command getCommand(Request request) { + if (request.getType().equals("rename")) + return createRenameCommand(request); + return null; + } + + protected Command createRenameCommand(Request renameRequest) { + RenameCommand command = new RenameCommand(); + command.setControl(((BControl) getHost().getModel())); + command.setNewString(((String) renameRequest.getExtendedData().get( + "newName"))); + return command; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/eventb/MachineOperation.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/eventb/MachineOperation.java index 60dfda23926c777d1b50371ae9d01371eb0c7a82..ae42a58e5040685ace6296e11fea66679775eb70 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/eventb/MachineOperation.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/eventb/MachineOperation.java @@ -1,44 +1,44 @@ -/** - * (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.bmotionstudio.gef.editor.eventb; - -import java.util.ArrayList; -import java.util.List; - -public class MachineOperation extends MachineContentObject { - - private List<String> parameters; - private List<String> guards; - - public MachineOperation(String label, List<String> parameters, - List<String> guards) { - super(label); - this.parameters = parameters; - this.guards = guards; - } - - public MachineOperation(String label) { - super(label); - } - - public List<String> getParameters() { - return this.parameters; - } - - public List<String> getGuards() { - return guards; - } - - public void setParameters(ArrayList<String> parameters) { - this.parameters = parameters; - } - - public void setGuards(ArrayList<String> guards) { - this.guards = guards; - } - -} +/** + * (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.bmotionstudio.gef.editor.eventb; + +import java.util.ArrayList; +import java.util.List; + +public class MachineOperation extends MachineContentObject { + + private List<String> parameters; + private List<String> guards; + + public MachineOperation(String label, List<String> parameters, + List<String> guards) { + super(label); + this.parameters = parameters; + this.guards = guards; + } + + public MachineOperation(String label) { + super(label); + } + + public List<String> getParameters() { + return this.parameters; + } + + public List<String> getGuards() { + return guards; + } + + public void setParameters(ArrayList<String> parameters) { + this.parameters = parameters; + } + + public void setGuards(ArrayList<String> guards) { + this.guards = guards; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ButtonFigure.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ButtonFigure.java index 1f7602a791c16a1e62669406ef4f58d82b98615d..bc93d479ed950ae32c85284325fbcf6a33af51bf 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ButtonFigure.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ButtonFigure.java @@ -1,89 +1,89 @@ -/** - * (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.bmotionstudio.gef.editor.figure; - -import org.eclipse.draw2d.ButtonBorder; -import org.eclipse.draw2d.ColorConstants; -import org.eclipse.draw2d.Graphics; -import org.eclipse.draw2d.Label; -import org.eclipse.draw2d.StackLayout; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.swt.graphics.Color; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -public class ButtonFigure extends AbstractBMotionFigure { - - private Label txtLabel; - private Color backgroundColor; - private Color foregroundColor; - - public ButtonFigure() { - setLayoutManager(new StackLayout()); - txtLabel = new Label("Click"); - add(txtLabel); - setOpaque(true); - setBorder(new ButtonBorder()); - } - - public void setText(String text) { - txtLabel.setText(text); - } - - public void setBackgroundColor(RGB rgb) { - if (backgroundColor != null) - backgroundColor.dispose(); - backgroundColor = new Color(Display.getDefault(), rgb); - setBackgroundColor(backgroundColor); - } - - public void setTextColor(RGB rgb) { - if (foregroundColor != null) - foregroundColor.dispose(); - foregroundColor = new Color(Display.getDefault(), rgb); - setForegroundColor(foregroundColor); - } - - public void setBtEnabled(Boolean bool) { - txtLabel.setEnabled(bool); - repaint(); - } - - /* - * (non-Javadoc) - * - * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() - */ - @Override - public void deactivateFigure() { - if (backgroundColor != null) - backgroundColor.dispose(); - if (foregroundColor != null) - foregroundColor.dispose(); - } - - @Override - protected void paintBorder(Graphics graphics) { - super.paintBorder(graphics); - if (hasFocus()) { - graphics.setForegroundColor(ColorConstants.black); - graphics.setBackgroundColor(ColorConstants.white); - Rectangle area = getClientArea(); - graphics.drawFocus(area.x, area.y, area.width, area.height); - } - } - - @Override - protected void paintClientArea(Graphics graphics) { - graphics.translate(1, 1); - graphics.pushState(); - super.paintClientArea(graphics); - graphics.popState(); - graphics.translate(-1, -1); - } - -} +/** + * (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.bmotionstudio.gef.editor.figure; + +import org.eclipse.draw2d.ButtonBorder; +import org.eclipse.draw2d.ColorConstants; +import org.eclipse.draw2d.Graphics; +import org.eclipse.draw2d.Label; +import org.eclipse.draw2d.StackLayout; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +public class ButtonFigure extends AbstractBMotionFigure { + + private Label txtLabel; + private Color backgroundColor; + private Color foregroundColor; + + public ButtonFigure() { + setLayoutManager(new StackLayout()); + txtLabel = new Label("Click"); + add(txtLabel); + setOpaque(true); + setBorder(new ButtonBorder()); + } + + public void setText(String text) { + txtLabel.setText(text); + } + + public void setBackgroundColor(RGB rgb) { + if (backgroundColor != null) + backgroundColor.dispose(); + backgroundColor = new Color(Display.getDefault(), rgb); + setBackgroundColor(backgroundColor); + } + + public void setTextColor(RGB rgb) { + if (foregroundColor != null) + foregroundColor.dispose(); + foregroundColor = new Color(Display.getDefault(), rgb); + setForegroundColor(foregroundColor); + } + + public void setBtEnabled(Boolean bool) { + txtLabel.setEnabled(bool); + repaint(); + } + + /* + * (non-Javadoc) + * + * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() + */ + @Override + public void deactivateFigure() { + if (backgroundColor != null) + backgroundColor.dispose(); + if (foregroundColor != null) + foregroundColor.dispose(); + } + + @Override + protected void paintBorder(Graphics graphics) { + super.paintBorder(graphics); + if (hasFocus()) { + graphics.setForegroundColor(ColorConstants.black); + graphics.setBackgroundColor(ColorConstants.white); + Rectangle area = getClientArea(); + graphics.drawFocus(area.x, area.y, area.width, area.height); + } + } + + @Override + protected void paintClientArea(Graphics graphics) { + graphics.translate(1, 1); + graphics.pushState(); + super.paintClientArea(graphics); + graphics.popState(); + graphics.translate(-1, -1); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CanisterFigure.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CanisterFigure.java index 248ff6825d76105b27f27a8bd1a7f5d0a1fc5819..f04abbd7011c631262473726ee75318def355721 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CanisterFigure.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CanisterFigure.java @@ -1,190 +1,190 @@ -/** - * (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.bmotionstudio.gef.editor.figure; - -import org.eclipse.draw2d.BorderLayout; -import org.eclipse.draw2d.ColorConstants; -import org.eclipse.draw2d.Figure; -import org.eclipse.draw2d.Graphics; -import org.eclipse.draw2d.Label; -import org.eclipse.draw2d.PositionConstants; -import org.eclipse.draw2d.RectangleFigure; -import org.eclipse.draw2d.XYLayout; -import org.eclipse.draw2d.geometry.Point; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.swt.graphics.Color; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.ImageData; -import org.eclipse.swt.graphics.PaletteData; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -public class CanisterFigure extends AbstractBMotionFigure { - - private RectangleFigure axisRect; - private Figure axisFigure; - private RectangleFigure fillRect; - private Figure fillFigure; - - private Image layerImage; - private ImageData imageData; - - private int fill_height; - private double positions; - private int show_pos; - - private Boolean showMeasure; - - public CanisterFigure() { - - XYLayout layout = new XYLayout(); - setLayoutManager(layout); - - PaletteData palette = new PaletteData( - new RGB[] { ColorConstants.white.getRGB() }); - imageData = new ImageData(1, 1, 8, palette); - imageData.alpha = 255; - imageData.setPixel(0, 0, 0); - layerImage = new Image(null, imageData); - - axisFigure = new Figure(); - axisFigure.setLocation(new Point(0, 0)); - axisFigure.setLayoutManager(new XYLayout()); - add(axisFigure); - - fillFigure = new Figure(); - fillFigure.setLayoutManager(new BorderLayout()); - add(fillFigure); - - fillRect = new RectangleFigure(); - fillRect.setOutline(false); - fillFigure.add(fillRect); - fillFigure.setConstraint(fillRect, BorderLayout.BOTTOM); - - setOpaque(true); - - } - - public void setLayout(Rectangle rect) { - - getParent().setConstraint(this, rect); - - // Set the right size and position of the y-axis - axisFigure.removeAll(); - - int fillPos = 0; - - double one_pos = Double.valueOf(rect.height) / positions; - - if (showMeasure) { - - axisFigure.setSize(100, rect.height); - - axisRect = new RectangleFigure(); - axisFigure.add(axisRect); - axisRect.setBackgroundColor(ColorConstants.black); - axisFigure.setConstraint(axisRect, new Rectangle(14, 0, 1, - rect.height)); - - RectangleFigure line; - Label lb; - - for (int i = 0; i <= positions; i = i + show_pos) { - - lb = new Label(); - axisFigure.add(lb); - lb.setText(String.valueOf((int) (positions - i))); - lb.setBackgroundColor(ColorConstants.red); - lb.setTextAlignment(PositionConstants.LEFT); - - if (i == 0) { - axisFigure.setConstraint(lb, new Rectangle(18, - (int) (i * one_pos), 30, 10)); - } else if (i == positions) { - axisFigure.setConstraint(lb, new Rectangle(18, - (int) (i * one_pos) - 10, 30, 10)); - } else { - axisFigure.setConstraint(lb, new Rectangle(18, - (int) (i * one_pos) - 5, 30, 10)); - } - - line = new RectangleFigure(); - line.setBackgroundColor(ColorConstants.black); - line.setOutline(false); - axisFigure.add(line); - - if (i == positions) { - axisFigure.setConstraint(line, new Rectangle(10, - (int) (i * one_pos) - 1, 10, 1)); - } else { - axisFigure.setConstraint(line, new Rectangle(10, - (int) (i * one_pos), 10, 1)); - } - - } - - fillPos = 60; - - } - - // Set right size of the fill figure - setConstraint(fillFigure, new Rectangle(fillPos, 0, rect.width - - fillPos, rect.height)); - - double tmp = one_pos * (positions - Double.valueOf(fill_height)); - int f_fill_height = (int) tmp; - fillRect.setSize(rect.width - fillPos, rect.height - f_fill_height); - fillFigure.setConstraint(fillRect, BorderLayout.BOTTOM); - fillFigure.repaint(); - - } - - public void setAlpha(int alpha) { - imageData.alpha = alpha; - if (layerImage != null && !layerImage.isDisposed()) { - layerImage.dispose(); - } - layerImage = new Image(null, imageData); - repaint(); - } - - public void paintFigure(Graphics g) { - Rectangle rectangle = getClientArea(); - g.drawImage(layerImage, new Rectangle(layerImage.getBounds()), - rectangle); - } - - public void setFillColor(RGB rgb) { - fillRect.setBackgroundColor(new Color(Display.getDefault(), rgb)); - } - - public void setFillHeight(Integer height) { - this.fill_height = height; - } - - public void setMaxPos(Integer maxPos) { - this.positions = maxPos; - } - - public void setInterval(Integer interval) { - this.show_pos = interval; - } - - public void setMeasure(Boolean bol) { - this.showMeasure = bol; - } - - public void setBackgroundColor(RGB rgb) { - imageData.palette.colors[0] = rgb; - if (layerImage != null && !layerImage.isDisposed()) { - layerImage.dispose(); - } - layerImage = new Image(null, imageData); - repaint(); - } - -} +/** + * (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.bmotionstudio.gef.editor.figure; + +import org.eclipse.draw2d.BorderLayout; +import org.eclipse.draw2d.ColorConstants; +import org.eclipse.draw2d.Figure; +import org.eclipse.draw2d.Graphics; +import org.eclipse.draw2d.Label; +import org.eclipse.draw2d.PositionConstants; +import org.eclipse.draw2d.RectangleFigure; +import org.eclipse.draw2d.XYLayout; +import org.eclipse.draw2d.geometry.Point; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.PaletteData; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +public class CanisterFigure extends AbstractBMotionFigure { + + private RectangleFigure axisRect; + private Figure axisFigure; + private RectangleFigure fillRect; + private Figure fillFigure; + + private Image layerImage; + private ImageData imageData; + + private int fill_height; + private double positions; + private int show_pos; + + private Boolean showMeasure; + + public CanisterFigure() { + + XYLayout layout = new XYLayout(); + setLayoutManager(layout); + + PaletteData palette = new PaletteData( + new RGB[] { ColorConstants.white.getRGB() }); + imageData = new ImageData(1, 1, 8, palette); + imageData.alpha = 255; + imageData.setPixel(0, 0, 0); + layerImage = new Image(null, imageData); + + axisFigure = new Figure(); + axisFigure.setLocation(new Point(0, 0)); + axisFigure.setLayoutManager(new XYLayout()); + add(axisFigure); + + fillFigure = new Figure(); + fillFigure.setLayoutManager(new BorderLayout()); + add(fillFigure); + + fillRect = new RectangleFigure(); + fillRect.setOutline(false); + fillFigure.add(fillRect); + fillFigure.setConstraint(fillRect, BorderLayout.BOTTOM); + + setOpaque(true); + + } + + public void setLayout(Rectangle rect) { + + getParent().setConstraint(this, rect); + + // Set the right size and position of the y-axis + axisFigure.removeAll(); + + int fillPos = 0; + + double one_pos = Double.valueOf(rect.height) / positions; + + if (showMeasure) { + + axisFigure.setSize(100, rect.height); + + axisRect = new RectangleFigure(); + axisFigure.add(axisRect); + axisRect.setBackgroundColor(ColorConstants.black); + axisFigure.setConstraint(axisRect, new Rectangle(14, 0, 1, + rect.height)); + + RectangleFigure line; + Label lb; + + for (int i = 0; i <= positions; i = i + show_pos) { + + lb = new Label(); + axisFigure.add(lb); + lb.setText(String.valueOf((int) (positions - i))); + lb.setBackgroundColor(ColorConstants.red); + lb.setTextAlignment(PositionConstants.LEFT); + + if (i == 0) { + axisFigure.setConstraint(lb, new Rectangle(18, + (int) (i * one_pos), 30, 10)); + } else if (i == positions) { + axisFigure.setConstraint(lb, new Rectangle(18, + (int) (i * one_pos) - 10, 30, 10)); + } else { + axisFigure.setConstraint(lb, new Rectangle(18, + (int) (i * one_pos) - 5, 30, 10)); + } + + line = new RectangleFigure(); + line.setBackgroundColor(ColorConstants.black); + line.setOutline(false); + axisFigure.add(line); + + if (i == positions) { + axisFigure.setConstraint(line, new Rectangle(10, + (int) (i * one_pos) - 1, 10, 1)); + } else { + axisFigure.setConstraint(line, new Rectangle(10, + (int) (i * one_pos), 10, 1)); + } + + } + + fillPos = 60; + + } + + // Set right size of the fill figure + setConstraint(fillFigure, new Rectangle(fillPos, 0, rect.width + - fillPos, rect.height)); + + double tmp = one_pos * (positions - Double.valueOf(fill_height)); + int f_fill_height = (int) tmp; + fillRect.setSize(rect.width - fillPos, rect.height - f_fill_height); + fillFigure.setConstraint(fillRect, BorderLayout.BOTTOM); + fillFigure.repaint(); + + } + + public void setAlpha(int alpha) { + imageData.alpha = alpha; + if (layerImage != null && !layerImage.isDisposed()) { + layerImage.dispose(); + } + layerImage = new Image(null, imageData); + repaint(); + } + + public void paintFigure(Graphics g) { + Rectangle rectangle = getClientArea(); + g.drawImage(layerImage, new Rectangle(layerImage.getBounds()), + rectangle); + } + + public void setFillColor(RGB rgb) { + fillRect.setBackgroundColor(new Color(Display.getDefault(), rgb)); + } + + public void setFillHeight(Integer height) { + this.fill_height = height; + } + + public void setMaxPos(Integer maxPos) { + this.positions = maxPos; + } + + public void setInterval(Integer interval) { + this.show_pos = interval; + } + + public void setMeasure(Boolean bol) { + this.showMeasure = bol; + } + + public void setBackgroundColor(RGB rgb) { + imageData.palette.colors[0] = rgb; + if (layerImage != null && !layerImage.isDisposed()) { + layerImage.dispose(); + } + layerImage = new Image(null, imageData); + repaint(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CompositeFigure.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CompositeFigure.java index 6f6414e7bf4ac385d707586ab4e6fb5e3fb31f14..3dd9ed8e42ad1ce137364e0b2564336c5c9f2434 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CompositeFigure.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/CompositeFigure.java @@ -1,145 +1,145 @@ -/** - * (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.bmotionstudio.gef.editor.figure; - -import org.eclipse.draw2d.ColorConstants; -import org.eclipse.draw2d.Graphics; -import org.eclipse.draw2d.XYLayout; -import org.eclipse.draw2d.geometry.Dimension; -import org.eclipse.draw2d.geometry.Insets; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.ImageData; -import org.eclipse.swt.graphics.PaletteData; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -public class CompositeFigure extends AbstractBMotionFigure { - - protected Image layerImage; - private ImageData imageData; - private Dimension size = new Dimension(); - private boolean hasImage; - - public CompositeFigure() { - XYLayout layout = new XYLayout(); - setLayoutManager(layout); - PaletteData palette = new PaletteData( - new RGB[] { ColorConstants.white.getRGB() }); - imageData = new ImageData(1, 1, 8, palette); - imageData.alpha = 255; - imageData.setPixel(0, 0, 0); - layerImage = new Image(Display.getDefault(), imageData); - hasImage = false; - setOpaque(true); - } - - // public void setAlpha(int alpha) { - // imageData.alpha = alpha; - // if (!hasImage) { - // if (layerImage != null && !layerImage.isDisposed()) { - // layerImage.dispose(); - // } - // layerImage = new Image(Display.getDefault(), imageData); - // repaint(); - // } - // } - - public void setBackgroundColor(RGB rgb) { - imageData.palette.colors[0] = rgb; - if (!hasImage) { - if (layerImage != null && !layerImage.isDisposed()) { - layerImage.dispose(); - } - layerImage = new Image(Display.getDefault(), imageData); - repaint(); - } - } - - public void paintFigure(Graphics g) { - if (getImage() == null) - return; - Rectangle rectangle = getClientArea(); - if (hasImage) { - int aWidth = rectangle.width; - int aHeight = rectangle.height; - int countX = aWidth / getImage().getBounds().width; - int countY = aHeight / getImage().getBounds().height; - for (int i = 0; i <= countX; i++) { - for (int z = 0; z <= countY; z++) { - g.drawImage(getImage(), getBounds().x + i - * getImage().getBounds().width, getBounds().y + z - * getImage().getBounds().height); - } - } - } else { - g.drawImage(getImage(), 0, 0, 1, 1, rectangle.x, rectangle.y, - rectangle.width, rectangle.height); - } - } - - /** - * Sets the Image that this ImageFigure displays. - * <p> - * IMPORTANT: Note that it is the client's responsibility to dispose the - * given image. - * - * @param image - * The Image to be displayed. It can be <code>null</code>. - */ - public void setImage(Image image) { - if (layerImage != null) - layerImage.dispose(); - layerImage = image; - if (layerImage != null) { - size = new Rectangle(image.getBounds()).getSize(); - hasImage = true; - } else { - layerImage = new Image(null, imageData); - size = new Dimension(); - hasImage = false; - } - revalidate(); - repaint(); - } - - /** - * @return The Image that this Figure displays - */ - public Image getImage() { - return layerImage; - } - - /** - * Calculates the necessary size to display the Image within the figure's - * client area. - * - * @see org.eclipse.draw2d.Figure#getPreferredSize(int, int) - */ - public Dimension getPreferredSize(int wHint, int hHint) { - if (getInsets() == NO_INSETS) - return size; - Insets i = getInsets(); - return size.getExpanded(i.getWidth(), i.getHeight()); - } - - public void setLayout(Rectangle rect) { - getParent().setConstraint(this, rect); - } - - /* - * (non-Javadoc) - * - * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() - */ - @Override - public void deactivateFigure() { - if (layerImage != null) - layerImage.dispose(); - } - -} +/** + * (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.bmotionstudio.gef.editor.figure; + +import org.eclipse.draw2d.ColorConstants; +import org.eclipse.draw2d.Graphics; +import org.eclipse.draw2d.XYLayout; +import org.eclipse.draw2d.geometry.Dimension; +import org.eclipse.draw2d.geometry.Insets; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.PaletteData; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +public class CompositeFigure extends AbstractBMotionFigure { + + protected Image layerImage; + private ImageData imageData; + private Dimension size = new Dimension(); + private boolean hasImage; + + public CompositeFigure() { + XYLayout layout = new XYLayout(); + setLayoutManager(layout); + PaletteData palette = new PaletteData( + new RGB[] { ColorConstants.white.getRGB() }); + imageData = new ImageData(1, 1, 8, palette); + imageData.alpha = 255; + imageData.setPixel(0, 0, 0); + layerImage = new Image(Display.getDefault(), imageData); + hasImage = false; + setOpaque(true); + } + + // public void setAlpha(int alpha) { + // imageData.alpha = alpha; + // if (!hasImage) { + // if (layerImage != null && !layerImage.isDisposed()) { + // layerImage.dispose(); + // } + // layerImage = new Image(Display.getDefault(), imageData); + // repaint(); + // } + // } + + public void setBackgroundColor(RGB rgb) { + imageData.palette.colors[0] = rgb; + if (!hasImage) { + if (layerImage != null && !layerImage.isDisposed()) { + layerImage.dispose(); + } + layerImage = new Image(Display.getDefault(), imageData); + repaint(); + } + } + + public void paintFigure(Graphics g) { + if (getImage() == null) + return; + Rectangle rectangle = getClientArea(); + if (hasImage) { + int aWidth = rectangle.width; + int aHeight = rectangle.height; + int countX = aWidth / getImage().getBounds().width; + int countY = aHeight / getImage().getBounds().height; + for (int i = 0; i <= countX; i++) { + for (int z = 0; z <= countY; z++) { + g.drawImage(getImage(), getBounds().x + i + * getImage().getBounds().width, getBounds().y + z + * getImage().getBounds().height); + } + } + } else { + g.drawImage(getImage(), 0, 0, 1, 1, rectangle.x, rectangle.y, + rectangle.width, rectangle.height); + } + } + + /** + * Sets the Image that this ImageFigure displays. + * <p> + * IMPORTANT: Note that it is the client's responsibility to dispose the + * given image. + * + * @param image + * The Image to be displayed. It can be <code>null</code>. + */ + public void setImage(Image image) { + if (layerImage != null) + layerImage.dispose(); + layerImage = image; + if (layerImage != null) { + size = new Rectangle(image.getBounds()).getSize(); + hasImage = true; + } else { + layerImage = new Image(null, imageData); + size = new Dimension(); + hasImage = false; + } + revalidate(); + repaint(); + } + + /** + * @return The Image that this Figure displays + */ + public Image getImage() { + return layerImage; + } + + /** + * Calculates the necessary size to display the Image within the figure's + * client area. + * + * @see org.eclipse.draw2d.Figure#getPreferredSize(int, int) + */ + public Dimension getPreferredSize(int wHint, int hHint) { + if (getInsets() == NO_INSETS) + return size; + Insets i = getInsets(); + return size.getExpanded(i.getWidth(), i.getHeight()); + } + + public void setLayout(Rectangle rect) { + getParent().setConstraint(this, rect); + } + + /* + * (non-Javadoc) + * + * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() + */ + @Override + public void deactivateFigure() { + if (layerImage != null) + layerImage.dispose(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ShapeFigure.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ShapeFigure.java index 9986a37d507bb38569b09240da5809fc5e997c07..beb832c773d4bd6903080049af74f4c51dff4645 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ShapeFigure.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/ShapeFigure.java @@ -1,430 +1,430 @@ -/** - * (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.bmotionstudio.gef.editor.figure; - -import org.eclipse.draw2d.ColorConstants; -import org.eclipse.draw2d.Figure; -import org.eclipse.draw2d.Graphics; -import org.eclipse.draw2d.IFigure; -import org.eclipse.draw2d.Orientable; -import org.eclipse.draw2d.PositionConstants; -import org.eclipse.draw2d.Shape; -import org.eclipse.draw2d.StackLayout; -import org.eclipse.draw2d.geometry.Point; -import org.eclipse.draw2d.geometry.PointList; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.swt.SWT; -import org.eclipse.swt.graphics.Color; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.ImageData; -import org.eclipse.swt.graphics.PaletteData; -import org.eclipse.swt.graphics.Pattern; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; - -public class ShapeFigure extends AbstractBMotionFigure { - - private int alpha; - private int outlineAlpha; - private int shape; - private Integer fillType; - private Image img; - private Color foregroundColor; - private Color backgroundColor; - - private Image patternImage; - private Image shadedImage; - private Pattern pattern; - private Pattern shadedPattern; - private Pattern gradientPattern; - - private final Color white = Display.getDefault().getSystemColor( - SWT.COLOR_WHITE); - - private static final int FILL_TYPE_FILLED = 0; - private static final int FILL_TYPE_EMPTY = 1; - private static final int FILL_TYPE_SHADED = 2; - private static final int FILL_TYPE_GRADIENT = 3; - - private static final int SHAPE_TYPE_RECTANGLE = 0; - private static final int SHAPE_TYPE_OVAL = 1; - private static final int SHAPE_TYPE_TRIANGLE = 2; - private static final int SHAPE_TYPE_DIAMOND = 3; - - /** - * The direction this triangle will face. Possible values are - * {@link PositionConstants#NORTH}, {@link PositionConstants#SOUTH}, - * {@link PositionConstants#EAST} and {@link PositionConstants#WEST}. - */ - protected int direction = PositionConstants.NORTH; - /** - * The orientation of this triangle. Possible values are - * {@link Orientable#VERTICAL} and {@link Orientable#HORIZONTAL}. - */ - protected int orientation = PositionConstants.VERTICAL; - - /** The points of the triangle. */ - protected PointList triangle = new PointList(3); - - /** The points of the diamond. */ - protected PointList diamond = new PointList(4); - - private Shape shapeFigure; - - public ShapeFigure() { - setLayoutManager(new StackLayout()); - shapeFigure = new Shape() { - - @Override - protected void fillShape(Graphics g) { - - g.setAlpha(alpha); - g.setAntialias(SWT.ON); - - if (fillType == FILL_TYPE_GRADIENT) { // Gradient fill type - - if (gradientPattern != null) - gradientPattern.dispose(); - gradientPattern = new Pattern(Display.getDefault(), - this.getBounds().x, this.getBounds().y, - this.getBounds().x + this.getBounds().width, - this.getBounds().y + this.getBounds().height, - this.getBackgroundColor(), - this.getForegroundColor()); - g.setBackgroundPattern(gradientPattern); - - } else if (fillType == FILL_TYPE_SHADED) { // Shaded fill type - - Color black = this.getForegroundColor(); - PaletteData palette = new PaletteData(new RGB[] { - white.getRGB(), black.getRGB() }); - ImageData sourceData = new ImageData(11, 11, 1, palette); - for (int i = 0; i < 11; i++) { - sourceData.setPixel(6, i, 1); - } - if (shadedImage != null) - shadedImage.dispose(); - shadedImage = new Image(Display.getDefault(), sourceData); - - if (shadedPattern != null) - shadedPattern.dispose(); - shadedPattern = new Pattern(Display.getDefault(), - shadedImage); - g.setBackgroundPattern(shadedPattern); - - } else if (fillType == FILL_TYPE_FILLED && img != null) { - - double zoom = 1; - if (BMotionEditorPlugin.getActiveEditor() != null) - zoom = BMotionEditorPlugin.getActiveEditor() - .getZoomFactor(); - - ImageData d = img.getImageData().scaledTo( - (int) (img.getBounds().width * zoom), - (int) (img.getBounds().height * zoom)); - - if (patternImage != null) - patternImage.dispose(); - - patternImage = new Image(Display.getDefault(), d); - - if (pattern != null) - pattern.dispose(); - - pattern = new Pattern(Display.getDefault(), patternImage); - - g.setBackgroundPattern(pattern); - - } else if (fillType == FILL_TYPE_FILLED) { - g.setBackgroundColor(this.getBackgroundColor()); - } - - switch (shape) { - case SHAPE_TYPE_RECTANGLE: - g.fillRectangle(this.getBounds()); - break; - case SHAPE_TYPE_OVAL: - g.fillOval(this.getBounds()); - break; - case SHAPE_TYPE_TRIANGLE: - g.fillPolygon(triangle); - break; - case SHAPE_TYPE_DIAMOND: - g.fillPolygon(diamond); - break; - default: - break; - } - - } - - @Override - protected void outlineShape(Graphics g) { - - g.setAlpha(outlineAlpha); - g.setAntialias(SWT.ON); - g.setForegroundColor(this.getForegroundColor()); - - float lineInset = Math.max(1.0f, getLineWidthFloat()) / 2.0f; - int inset1 = (int) Math.floor(lineInset); - int inset2 = (int) Math.ceil(lineInset); - - Rectangle r = Rectangle.SINGLETON.setBounds(this.getBounds()); - r.x += inset1; - r.y += inset1; - r.width -= inset1 + inset2; - r.height -= inset1 + inset2; - - switch (shape) { - case SHAPE_TYPE_RECTANGLE: - g.drawRectangle(r); - break; - case SHAPE_TYPE_OVAL: - g.drawOval(r); - break; - case SHAPE_TYPE_TRIANGLE: - g.drawPolygon(triangle); - break; - case SHAPE_TYPE_DIAMOND: - g.drawPolygon(diamond); - break; - default: - break; - } - - } - - }; - shapeFigure.setForegroundColor(ColorConstants.blue); - // setOpaque(true); - add(shapeFigure); - } - - /** - * @see Orientable#setDirection(int) - */ - public void setDirection(int value) { - if ((value & (PositionConstants.NORTH | PositionConstants.SOUTH)) != 0) - orientation = PositionConstants.VERTICAL; - else - orientation = PositionConstants.HORIZONTAL; - direction = value; - revalidate(); - repaint(); - } - - /** - * @see Orientable#setOrientation(int) - */ - public void setOrientation(int value) { - if (orientation == PositionConstants.VERTICAL - && value == PositionConstants.HORIZONTAL) { - if (direction == PositionConstants.NORTH) - setDirection(PositionConstants.WEST); - else - setDirection(PositionConstants.EAST); - } - if (orientation == PositionConstants.HORIZONTAL - && value == PositionConstants.VERTICAL) { - if (direction == PositionConstants.WEST) - setDirection(PositionConstants.NORTH); - else - setDirection(PositionConstants.SOUTH); - } - } - - /** - * @see IFigure#validate() - */ - public void validate() { - - super.validate(); - - Rectangle r = new Rectangle(); - r.setBounds(getBounds()); - r.crop(getInsets()); - r.resize(-1, -1); - - switch (shape) { - - case SHAPE_TYPE_TRIANGLE: - - int size; - switch (direction - & (PositionConstants.NORTH | PositionConstants.SOUTH)) { - case 0: // East or west. - size = Math.min(r.height / 2, r.width); - r.x += (r.width - size) / 2; - break; - default: // North or south - size = Math.min(r.height, r.width / 2); - r.y += (r.height - size) / 2; - break; - } - - size = Math.max(size, 1); // Size cannot be negative - - Point head, - p2, - p3; - - switch (direction) { - case PositionConstants.NORTH: - head = new Point(r.x + r.width / 2, r.y); - p2 = new Point(head.x - size, head.y + size); - p3 = new Point(head.x + size, head.y + size); - break; - case PositionConstants.SOUTH: - head = new Point(r.x + r.width / 2, r.y + size); - p2 = new Point(head.x - size, head.y - size); - p3 = new Point(head.x + size, head.y - size); - break; - case PositionConstants.WEST: - head = new Point(r.x, r.y + r.height / 2); - p2 = new Point(head.x + size, head.y - size); - p3 = new Point(head.x + size, head.y + size); - break; - default: - head = new Point(r.x + size, r.y + r.height / 2); - p2 = new Point(head.x - size, head.y - size); - p3 = new Point(head.x - size, head.y + size); - - } - triangle.removeAllPoints(); - triangle.addPoint(head); - triangle.addPoint(p2); - triangle.addPoint(p3); - - break; - - case SHAPE_TYPE_DIAMOND: - - Point pt1 = new Point(r.x + r.width / 2, r.y); - Point pt2 = new Point(r.x + r.width, r.y + r.height / 2); - Point pt3 = new Point(r.x + r.width / 2, r.y + r.height); - Point pt4 = new Point(r.x, r.y + r.height / 2); - - diamond.removeAllPoints(); - diamond.addPoint(pt1); - diamond.addPoint(pt2); - diamond.addPoint(pt3); - diamond.addPoint(pt4); - - break; - - default: - break; - } - - } - - /** - * @see Figure#primTranslate(int, int) - */ - public void primTranslate(int dx, int dy) { - super.primTranslate(dx, dy); - switch (shape) { - case SHAPE_TYPE_TRIANGLE: - triangle.translate(dx, dy); - break; - case SHAPE_TYPE_DIAMOND: - diamond.translate(dx, dy); - break; - default: - break; - } - } - - public void setBackgroundColor(RGB rgb) { - if (backgroundColor != null) - backgroundColor.dispose(); - backgroundColor = new Color(Display.getDefault(), rgb); - shapeFigure.setBackgroundColor(backgroundColor); - } - - public void setForegroundColor(RGB rgb) { - if (foregroundColor != null) - foregroundColor.dispose(); - foregroundColor = new Color(Display.getDefault(), rgb); - shapeFigure.setForegroundColor(foregroundColor); - shapeFigure.repaint(); - } - - public void setLayout(Rectangle rect) { - getParent().setConstraint(this, rect); - } - - public void setShape(int shape) { - this.shape = shape; - revalidate(); - shapeFigure.repaint(); - } - - public int getShape() { - return shape; - } - - public Integer getAlpha() { - return alpha; - } - - public void setAlpha(Integer alpha) { - this.alpha = alpha; - repaint(); - } - - public Integer getOutlineAlpha() { - return outlineAlpha; - } - - public void setOutlineAlpha(Integer outlineAlpha) { - this.outlineAlpha = outlineAlpha; - repaint(); - } - - public void setFillType(Integer fillType) { - if (fillType == FILL_TYPE_EMPTY) - shapeFigure.setFill(false); - else - shapeFigure.setFill(true); - this.fillType = fillType; - repaint(); - } - - public void setImage(Image img) { - this.img = img; - repaint(); - } - - /* - * (non-Javadoc) - * - * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() - */ - @Override - public void deactivateFigure() { - if (img != null) - img.dispose(); - if (foregroundColor != null) - foregroundColor.dispose(); - if (backgroundColor != null) - backgroundColor.dispose(); - if (patternImage != null) - patternImage.dispose(); - if (shadedImage != null) - shadedImage.dispose(); - if (pattern != null) - pattern.dispose(); - if (shadedPattern != null) - shadedPattern.dispose(); - if (gradientPattern != null) - gradientPattern.dispose(); - } - -} +/** + * (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.bmotionstudio.gef.editor.figure; + +import org.eclipse.draw2d.ColorConstants; +import org.eclipse.draw2d.Figure; +import org.eclipse.draw2d.Graphics; +import org.eclipse.draw2d.IFigure; +import org.eclipse.draw2d.Orientable; +import org.eclipse.draw2d.PositionConstants; +import org.eclipse.draw2d.Shape; +import org.eclipse.draw2d.StackLayout; +import org.eclipse.draw2d.geometry.Point; +import org.eclipse.draw2d.geometry.PointList; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.PaletteData; +import org.eclipse.swt.graphics.Pattern; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; + +public class ShapeFigure extends AbstractBMotionFigure { + + private int alpha; + private int outlineAlpha; + private int shape; + private Integer fillType; + private Image img; + private Color foregroundColor; + private Color backgroundColor; + + private Image patternImage; + private Image shadedImage; + private Pattern pattern; + private Pattern shadedPattern; + private Pattern gradientPattern; + + private final Color white = Display.getDefault().getSystemColor( + SWT.COLOR_WHITE); + + private static final int FILL_TYPE_FILLED = 0; + private static final int FILL_TYPE_EMPTY = 1; + private static final int FILL_TYPE_SHADED = 2; + private static final int FILL_TYPE_GRADIENT = 3; + + private static final int SHAPE_TYPE_RECTANGLE = 0; + private static final int SHAPE_TYPE_OVAL = 1; + private static final int SHAPE_TYPE_TRIANGLE = 2; + private static final int SHAPE_TYPE_DIAMOND = 3; + + /** + * The direction this triangle will face. Possible values are + * {@link PositionConstants#NORTH}, {@link PositionConstants#SOUTH}, + * {@link PositionConstants#EAST} and {@link PositionConstants#WEST}. + */ + protected int direction = PositionConstants.NORTH; + /** + * The orientation of this triangle. Possible values are + * {@link Orientable#VERTICAL} and {@link Orientable#HORIZONTAL}. + */ + protected int orientation = PositionConstants.VERTICAL; + + /** The points of the triangle. */ + protected PointList triangle = new PointList(3); + + /** The points of the diamond. */ + protected PointList diamond = new PointList(4); + + private Shape shapeFigure; + + public ShapeFigure() { + setLayoutManager(new StackLayout()); + shapeFigure = new Shape() { + + @Override + protected void fillShape(Graphics g) { + + g.setAlpha(alpha); + g.setAntialias(SWT.ON); + + if (fillType == FILL_TYPE_GRADIENT) { // Gradient fill type + + if (gradientPattern != null) + gradientPattern.dispose(); + gradientPattern = new Pattern(Display.getDefault(), + this.getBounds().x, this.getBounds().y, + this.getBounds().x + this.getBounds().width, + this.getBounds().y + this.getBounds().height, + this.getBackgroundColor(), + this.getForegroundColor()); + g.setBackgroundPattern(gradientPattern); + + } else if (fillType == FILL_TYPE_SHADED) { // Shaded fill type + + Color black = this.getForegroundColor(); + PaletteData palette = new PaletteData(new RGB[] { + white.getRGB(), black.getRGB() }); + ImageData sourceData = new ImageData(11, 11, 1, palette); + for (int i = 0; i < 11; i++) { + sourceData.setPixel(6, i, 1); + } + if (shadedImage != null) + shadedImage.dispose(); + shadedImage = new Image(Display.getDefault(), sourceData); + + if (shadedPattern != null) + shadedPattern.dispose(); + shadedPattern = new Pattern(Display.getDefault(), + shadedImage); + g.setBackgroundPattern(shadedPattern); + + } else if (fillType == FILL_TYPE_FILLED && img != null) { + + double zoom = 1; + if (BMotionEditorPlugin.getActiveEditor() != null) + zoom = BMotionEditorPlugin.getActiveEditor() + .getZoomFactor(); + + ImageData d = img.getImageData().scaledTo( + (int) (img.getBounds().width * zoom), + (int) (img.getBounds().height * zoom)); + + if (patternImage != null) + patternImage.dispose(); + + patternImage = new Image(Display.getDefault(), d); + + if (pattern != null) + pattern.dispose(); + + pattern = new Pattern(Display.getDefault(), patternImage); + + g.setBackgroundPattern(pattern); + + } else if (fillType == FILL_TYPE_FILLED) { + g.setBackgroundColor(this.getBackgroundColor()); + } + + switch (shape) { + case SHAPE_TYPE_RECTANGLE: + g.fillRectangle(this.getBounds()); + break; + case SHAPE_TYPE_OVAL: + g.fillOval(this.getBounds()); + break; + case SHAPE_TYPE_TRIANGLE: + g.fillPolygon(triangle); + break; + case SHAPE_TYPE_DIAMOND: + g.fillPolygon(diamond); + break; + default: + break; + } + + } + + @Override + protected void outlineShape(Graphics g) { + + g.setAlpha(outlineAlpha); + g.setAntialias(SWT.ON); + g.setForegroundColor(this.getForegroundColor()); + + float lineInset = Math.max(1.0f, getLineWidthFloat()) / 2.0f; + int inset1 = (int) Math.floor(lineInset); + int inset2 = (int) Math.ceil(lineInset); + + Rectangle r = Rectangle.SINGLETON.setBounds(this.getBounds()); + r.x += inset1; + r.y += inset1; + r.width -= inset1 + inset2; + r.height -= inset1 + inset2; + + switch (shape) { + case SHAPE_TYPE_RECTANGLE: + g.drawRectangle(r); + break; + case SHAPE_TYPE_OVAL: + g.drawOval(r); + break; + case SHAPE_TYPE_TRIANGLE: + g.drawPolygon(triangle); + break; + case SHAPE_TYPE_DIAMOND: + g.drawPolygon(diamond); + break; + default: + break; + } + + } + + }; + shapeFigure.setForegroundColor(ColorConstants.blue); + // setOpaque(true); + add(shapeFigure); + } + + /** + * @see Orientable#setDirection(int) + */ + public void setDirection(int value) { + if ((value & (PositionConstants.NORTH | PositionConstants.SOUTH)) != 0) + orientation = PositionConstants.VERTICAL; + else + orientation = PositionConstants.HORIZONTAL; + direction = value; + revalidate(); + repaint(); + } + + /** + * @see Orientable#setOrientation(int) + */ + public void setOrientation(int value) { + if (orientation == PositionConstants.VERTICAL + && value == PositionConstants.HORIZONTAL) { + if (direction == PositionConstants.NORTH) + setDirection(PositionConstants.WEST); + else + setDirection(PositionConstants.EAST); + } + if (orientation == PositionConstants.HORIZONTAL + && value == PositionConstants.VERTICAL) { + if (direction == PositionConstants.WEST) + setDirection(PositionConstants.NORTH); + else + setDirection(PositionConstants.SOUTH); + } + } + + /** + * @see IFigure#validate() + */ + public void validate() { + + super.validate(); + + Rectangle r = new Rectangle(); + r.setBounds(getBounds()); + r.crop(getInsets()); + r.resize(-1, -1); + + switch (shape) { + + case SHAPE_TYPE_TRIANGLE: + + int size; + switch (direction + & (PositionConstants.NORTH | PositionConstants.SOUTH)) { + case 0: // East or west. + size = Math.min(r.height / 2, r.width); + r.x += (r.width - size) / 2; + break; + default: // North or south + size = Math.min(r.height, r.width / 2); + r.y += (r.height - size) / 2; + break; + } + + size = Math.max(size, 1); // Size cannot be negative + + Point head, + p2, + p3; + + switch (direction) { + case PositionConstants.NORTH: + head = new Point(r.x + r.width / 2, r.y); + p2 = new Point(head.x - size, head.y + size); + p3 = new Point(head.x + size, head.y + size); + break; + case PositionConstants.SOUTH: + head = new Point(r.x + r.width / 2, r.y + size); + p2 = new Point(head.x - size, head.y - size); + p3 = new Point(head.x + size, head.y - size); + break; + case PositionConstants.WEST: + head = new Point(r.x, r.y + r.height / 2); + p2 = new Point(head.x + size, head.y - size); + p3 = new Point(head.x + size, head.y + size); + break; + default: + head = new Point(r.x + size, r.y + r.height / 2); + p2 = new Point(head.x - size, head.y - size); + p3 = new Point(head.x - size, head.y + size); + + } + triangle.removeAllPoints(); + triangle.addPoint(head); + triangle.addPoint(p2); + triangle.addPoint(p3); + + break; + + case SHAPE_TYPE_DIAMOND: + + Point pt1 = new Point(r.x + r.width / 2, r.y); + Point pt2 = new Point(r.x + r.width, r.y + r.height / 2); + Point pt3 = new Point(r.x + r.width / 2, r.y + r.height); + Point pt4 = new Point(r.x, r.y + r.height / 2); + + diamond.removeAllPoints(); + diamond.addPoint(pt1); + diamond.addPoint(pt2); + diamond.addPoint(pt3); + diamond.addPoint(pt4); + + break; + + default: + break; + } + + } + + /** + * @see Figure#primTranslate(int, int) + */ + public void primTranslate(int dx, int dy) { + super.primTranslate(dx, dy); + switch (shape) { + case SHAPE_TYPE_TRIANGLE: + triangle.translate(dx, dy); + break; + case SHAPE_TYPE_DIAMOND: + diamond.translate(dx, dy); + break; + default: + break; + } + } + + public void setBackgroundColor(RGB rgb) { + if (backgroundColor != null) + backgroundColor.dispose(); + backgroundColor = new Color(Display.getDefault(), rgb); + shapeFigure.setBackgroundColor(backgroundColor); + } + + public void setForegroundColor(RGB rgb) { + if (foregroundColor != null) + foregroundColor.dispose(); + foregroundColor = new Color(Display.getDefault(), rgb); + shapeFigure.setForegroundColor(foregroundColor); + shapeFigure.repaint(); + } + + public void setLayout(Rectangle rect) { + getParent().setConstraint(this, rect); + } + + public void setShape(int shape) { + this.shape = shape; + revalidate(); + shapeFigure.repaint(); + } + + public int getShape() { + return shape; + } + + public Integer getAlpha() { + return alpha; + } + + public void setAlpha(Integer alpha) { + this.alpha = alpha; + repaint(); + } + + public Integer getOutlineAlpha() { + return outlineAlpha; + } + + public void setOutlineAlpha(Integer outlineAlpha) { + this.outlineAlpha = outlineAlpha; + repaint(); + } + + public void setFillType(Integer fillType) { + if (fillType == FILL_TYPE_EMPTY) + shapeFigure.setFill(false); + else + shapeFigure.setFill(true); + this.fillType = fillType; + repaint(); + } + + public void setImage(Image img) { + this.img = img; + repaint(); + } + + /* + * (non-Javadoc) + * + * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() + */ + @Override + public void deactivateFigure() { + if (img != null) + img.dispose(); + if (foregroundColor != null) + foregroundColor.dispose(); + if (backgroundColor != null) + backgroundColor.dispose(); + if (patternImage != null) + patternImage.dispose(); + if (shadedImage != null) + shadedImage.dispose(); + if (pattern != null) + pattern.dispose(); + if (shadedPattern != null) + shadedPattern.dispose(); + if (gradientPattern != null) + gradientPattern.dispose(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/TextFigure.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/TextFigure.java index 0c8a51e21e6ab99ff2037ad9bc5b8a33d9466edb..4cbbc7d8a22a7e4e5aa80a94a95f99f82d3cef34 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/TextFigure.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/TextFigure.java @@ -1,101 +1,101 @@ -/** - * (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.bmotionstudio.gef.editor.figure; - -import org.eclipse.draw2d.MarginBorder; -import org.eclipse.draw2d.StackLayout; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.draw2d.text.FlowPage; -import org.eclipse.draw2d.text.ParagraphTextLayout; -import org.eclipse.draw2d.text.TextFlow; -import org.eclipse.swt.graphics.Color; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -public class TextFigure extends AbstractBMotionFigure { - - private TextFlow textFlow; - protected Image layerImage; - private Color foregroundColor; - private Font font; - - public TextFigure() { - setBorder(new MarginBorder(1)); - FlowPage flowPage = new FlowPage(); - textFlow = new TextFlow(); - textFlow.setLayoutManager(new ParagraphTextLayout(textFlow, - ParagraphTextLayout.WORD_WRAP_SOFT)); - flowPage.add(textFlow); - setLayoutManager(new StackLayout()); - add(flowPage); - } - - /** - * Returns the text inside the TextFlow. - * - * @return the text flow inside the text. - */ - public String getText() { - return textFlow.getText(); - } - - /** - * Sets the text of the TextFlow to the given value. - * - * @param newText - * the new text value. - */ - public void setText(String newText) { - textFlow.setText(newText); - } - - public void setTextColor(RGB rgb) { - if (foregroundColor != null) - foregroundColor.dispose(); - foregroundColor = new Color(Display.getDefault(), rgb); - textFlow.setForegroundColor(foregroundColor); - } - - public void setBackgroundVisible(Boolean bol) { - setOpaque(bol); - } - - public void setFont(String fontData) { - if (font != null) - font.dispose(); - font = new Font(Display.getDefault(), new FontData(fontData)); - textFlow.setFont(font); - } - - // TODO: CHECK STACK OVERFLOW ERROR!!!! - public Font getFont() { - return textFlow.getFont(); - } - - public void setLayout(Rectangle rect) { - getParent().setConstraint(this, rect); - } - - /* - * (non-Javadoc) - * - * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() - */ - @Override - public void deactivateFigure() { - if (foregroundColor != null) - foregroundColor.dispose(); - if (font != null) - font.dispose(); - if (layerImage != null) - layerImage.dispose(); - } - -} +/** + * (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.bmotionstudio.gef.editor.figure; + +import org.eclipse.draw2d.MarginBorder; +import org.eclipse.draw2d.StackLayout; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.draw2d.text.FlowPage; +import org.eclipse.draw2d.text.ParagraphTextLayout; +import org.eclipse.draw2d.text.TextFlow; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +public class TextFigure extends AbstractBMotionFigure { + + private TextFlow textFlow; + protected Image layerImage; + private Color foregroundColor; + private Font font; + + public TextFigure() { + setBorder(new MarginBorder(1)); + FlowPage flowPage = new FlowPage(); + textFlow = new TextFlow(); + textFlow.setLayoutManager(new ParagraphTextLayout(textFlow, + ParagraphTextLayout.WORD_WRAP_SOFT)); + flowPage.add(textFlow); + setLayoutManager(new StackLayout()); + add(flowPage); + } + + /** + * Returns the text inside the TextFlow. + * + * @return the text flow inside the text. + */ + public String getText() { + return textFlow.getText(); + } + + /** + * Sets the text of the TextFlow to the given value. + * + * @param newText + * the new text value. + */ + public void setText(String newText) { + textFlow.setText(newText); + } + + public void setTextColor(RGB rgb) { + if (foregroundColor != null) + foregroundColor.dispose(); + foregroundColor = new Color(Display.getDefault(), rgb); + textFlow.setForegroundColor(foregroundColor); + } + + public void setBackgroundVisible(Boolean bol) { + setOpaque(bol); + } + + public void setFont(String fontData) { + if (font != null) + font.dispose(); + font = new Font(Display.getDefault(), new FontData(fontData)); + textFlow.setFont(font); + } + + // TODO: CHECK STACK OVERFLOW ERROR!!!! + public Font getFont() { + return textFlow.getFont(); + } + + public void setLayout(Rectangle rect) { + getParent().setConstraint(this, rect); + } + + /* + * (non-Javadoc) + * + * @see de.bmotionstudio.gef.editor.figure.IBMotionFigure#deactivateFigure() + */ + @Override + public void deactivateFigure() { + if (foregroundColor != null) + foregroundColor.dispose(); + if (font != null) + font.dispose(); + if (layerImage != null) + layerImage.dispose(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/UnknownBControl.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/UnknownBControl.java index 120245cdb9b4ea6238a642da5cc35abdc2235c70..2e7fc294f18c0a839c962c67f437aff2660e9d8d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/UnknownBControl.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/figure/UnknownBControl.java @@ -1,47 +1,47 @@ -/** - * (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.bmotionstudio.gef.editor.figure; - -import org.eclipse.draw2d.ColorConstants; -import org.eclipse.draw2d.MarginBorder; -import org.eclipse.draw2d.StackLayout; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.draw2d.text.FlowPage; -import org.eclipse.draw2d.text.ParagraphTextLayout; -import org.eclipse.draw2d.text.TextFlow; - -public class UnknownBControl extends AbstractBMotionFigure { - - public static String ID = "de.bmotionstudio.gef.editor.unknown"; - - private final TextFlow textFlow; - - public UnknownBControl() { - setBorder(new MarginBorder(1)); - FlowPage flowPage = new FlowPage(); - textFlow = new TextFlow(); - textFlow.setLayoutManager(new ParagraphTextLayout(textFlow, - ParagraphTextLayout.WORD_WRAP_SOFT)); - flowPage.add(textFlow); - setLayoutManager(new StackLayout()); - add(flowPage); - setBackgroundColor(ColorConstants.red); - setOpaque(true); - } - - public void prepareForEditing() { - } - - public void setMessage(final String type) { - textFlow.setText("Unknown part: " + type); - } - - public void setLayout(final Rectangle rect) { - - } - -} +/** + * (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.bmotionstudio.gef.editor.figure; + +import org.eclipse.draw2d.ColorConstants; +import org.eclipse.draw2d.MarginBorder; +import org.eclipse.draw2d.StackLayout; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.draw2d.text.FlowPage; +import org.eclipse.draw2d.text.ParagraphTextLayout; +import org.eclipse.draw2d.text.TextFlow; + +public class UnknownBControl extends AbstractBMotionFigure { + + public static String ID = "de.bmotionstudio.gef.editor.unknown"; + + private final TextFlow textFlow; + + public UnknownBControl() { + setBorder(new MarginBorder(1)); + FlowPage flowPage = new FlowPage(); + textFlow = new TextFlow(); + textFlow.setLayoutManager(new ParagraphTextLayout(textFlow, + ParagraphTextLayout.WORD_WRAP_SOFT)); + flowPage.add(textFlow); + setLayoutManager(new StackLayout()); + add(flowPage); + setBackgroundColor(ColorConstants.red); + setOpaque(true); + } + + public void prepareForEditing() { + } + + public void setMessage(final String type) { + textFlow.setText("Unknown part: " + type); + } + + public void setLayout(final Rectangle rect) { + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/Animation.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/Animation.java index 1ad524efa4653e88249dce207a197c2ebac64f16..6ee861ea1649cebbb6882ddf585aa781aadcfd5a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/Animation.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/Animation.java @@ -1,164 +1,164 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import java.util.HashMap; -import java.util.Map; - -import org.eclipse.swt.widgets.Display; - -import de.bmotionstudio.gef.editor.animation.StaticListenerRegistry; -import de.bmotionstudio.gef.editor.model.Visualization; -import de.prob.core.Animator; -import de.prob.core.IAnimationListener; -import de.prob.core.command.EvaluationGetValuesCommand; -import de.prob.core.command.EvaluationInsertFormulaCommand; -import de.prob.core.command.EvaluationInsertFormulaCommand.FormulaType; -import de.prob.core.domainobjects.EvaluationElement; -import de.prob.core.domainobjects.Operation; -import de.prob.core.domainobjects.State; -import de.prob.exceptions.ProBException; -import de.prob.parserbase.ProBParseException; - -public class Animation implements IAnimationListener { - - private Animator animator; - - private final Map<String, Operation> currentStateOperations; - - private final Map<String, EvaluationElement> cachedEvalElements = new HashMap<String, EvaluationElement>(); - - private State currentState; - - private Visualization visualization; - - private Boolean observerCallBack = true; - - public Animation(Animator anim, Visualization visualization) { - StaticListenerRegistry.registerListener((IAnimationListener) this); - this.currentStateOperations = new HashMap<String, Operation>(); - this.animator = anim; - this.visualization = visualization; - this.visualization.setAnimation(this); - } - - private void setNewState(State state) { - currentState = state; - currentStateOperations.clear(); - for (Operation op : state.getEnabledOperations()) { - this.currentStateOperations.put(op.getName(), op); - } - } - - @Override - public void currentStateChanged(State currentState, Operation operation) { - // set new state and remember old state, if possible - setNewState(currentState); - updateCachedExpressions(currentState); - if (currentState.isInitialized()) { - - if (animator == null) { - animator = Animator.getAnimator(); - } - - checkObserver(); - - } - - } - - /** - * Get values for all used expressions. This should speed up the - * communication between ProB's core and Java. The result is not used, just - * to fill the caches. - * - * @param currentState - */ - private void updateCachedExpressions(State currentState) { - try { - EvaluationGetValuesCommand.getValuesForExpressionsCached( - currentState, cachedEvalElements.values()); - } catch (ProBException e) { - // TODO Log this - } - } - - public void checkObserver() { - if (visualization.isRunning()) { - Display.getDefault().asyncExec(new Runnable() { - @Override - public void run() { - visualization.checkObserver(Animation.this); - visualization.afterCheckObserver(Animation.this); - } - }); - } - } - - // public boolean checkObserverCallBack() { - // return visualization.checkObserverCallBack(); - // } - - public State getState() { - return currentState; - } - - public Animator getAnimator() { - return animator; - } - - public Operation getCurrentStateOperation(String operation) { - return currentStateOperations.get(operation); - } - - public Visualization getVisualization() { - return this.visualization; - } - - public void unregister() { - StaticListenerRegistry.unregisterListener((IAnimationListener) this); - } - - public void setObserverCallBack(Boolean observerCallBack) { - this.observerCallBack = observerCallBack; - } - - public boolean isObserverCallBack() { - return observerCallBack; - } - - public EvaluationElement getCachedEvalElement(String expressionStr, - boolean isPredicate) throws UnsupportedOperationException, - ProBException, ProBParseException { - final EvaluationElement evalElement; - if (cachedEvalElements.containsKey(expressionStr)) { - evalElement = cachedEvalElements.get(expressionStr); - } else { - // TODO: exception handling ... - evalElement = createPredicateExpressionElement(expressionStr, - isPredicate); - cachedEvalElements.put(expressionStr, evalElement); - } - return evalElement; - } - - private EvaluationElement createPredicateExpressionElement( - String expressionStr, boolean isPredicate) - throws UnsupportedOperationException, ProBException, - ProBParseException { - final EvaluationInsertFormulaCommand.FormulaType type = isPredicate ? FormulaType.PREDICATE - : FormulaType.EXPRESSION; - final EvaluationElement evaluationElement = EvaluationInsertFormulaCommand - .insertFormula(animator, type, expressionStr); - return evaluationElement; - } - - public Map<String, Operation> getCurrentStateOperations() { - return currentStateOperations; - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.swt.widgets.Display; + +import de.bmotionstudio.gef.editor.animation.StaticListenerRegistry; +import de.bmotionstudio.gef.editor.model.Visualization; +import de.prob.core.Animator; +import de.prob.core.IAnimationListener; +import de.prob.core.command.EvaluationGetValuesCommand; +import de.prob.core.command.EvaluationInsertFormulaCommand; +import de.prob.core.command.EvaluationInsertFormulaCommand.FormulaType; +import de.prob.core.domainobjects.EvaluationElement; +import de.prob.core.domainobjects.Operation; +import de.prob.core.domainobjects.State; +import de.prob.exceptions.ProBException; +import de.prob.parserbase.ProBParseException; + +public class Animation implements IAnimationListener { + + private Animator animator; + + private final Map<String, Operation> currentStateOperations; + + private final Map<String, EvaluationElement> cachedEvalElements = new HashMap<String, EvaluationElement>(); + + private State currentState; + + private Visualization visualization; + + private Boolean observerCallBack = true; + + public Animation(Animator anim, Visualization visualization) { + StaticListenerRegistry.registerListener((IAnimationListener) this); + this.currentStateOperations = new HashMap<String, Operation>(); + this.animator = anim; + this.visualization = visualization; + this.visualization.setAnimation(this); + } + + private void setNewState(State state) { + currentState = state; + currentStateOperations.clear(); + for (Operation op : state.getEnabledOperations()) { + this.currentStateOperations.put(op.getName(), op); + } + } + + @Override + public void currentStateChanged(State currentState, Operation operation) { + // set new state and remember old state, if possible + setNewState(currentState); + updateCachedExpressions(currentState); + if (currentState.isInitialized()) { + + if (animator == null) { + animator = Animator.getAnimator(); + } + + checkObserver(); + + } + + } + + /** + * Get values for all used expressions. This should speed up the + * communication between ProB's core and Java. The result is not used, just + * to fill the caches. + * + * @param currentState + */ + private void updateCachedExpressions(State currentState) { + try { + EvaluationGetValuesCommand.getValuesForExpressionsCached( + currentState, cachedEvalElements.values()); + } catch (ProBException e) { + // TODO Log this + } + } + + public void checkObserver() { + if (visualization.isRunning()) { + Display.getDefault().asyncExec(new Runnable() { + @Override + public void run() { + visualization.checkObserver(Animation.this); + visualization.afterCheckObserver(Animation.this); + } + }); + } + } + + // public boolean checkObserverCallBack() { + // return visualization.checkObserverCallBack(); + // } + + public State getState() { + return currentState; + } + + public Animator getAnimator() { + return animator; + } + + public Operation getCurrentStateOperation(String operation) { + return currentStateOperations.get(operation); + } + + public Visualization getVisualization() { + return this.visualization; + } + + public void unregister() { + StaticListenerRegistry.unregisterListener((IAnimationListener) this); + } + + public void setObserverCallBack(Boolean observerCallBack) { + this.observerCallBack = observerCallBack; + } + + public boolean isObserverCallBack() { + return observerCallBack; + } + + public EvaluationElement getCachedEvalElement(String expressionStr, + boolean isPredicate) throws UnsupportedOperationException, + ProBException, ProBParseException { + final EvaluationElement evalElement; + if (cachedEvalElements.containsKey(expressionStr)) { + evalElement = cachedEvalElements.get(expressionStr); + } else { + // TODO: exception handling ... + evalElement = createPredicateExpressionElement(expressionStr, + isPredicate); + cachedEvalElements.put(expressionStr, evalElement); + } + return evalElement; + } + + private EvaluationElement createPredicateExpressionElement( + String expressionStr, boolean isPredicate) + throws UnsupportedOperationException, ProBException, + ProBParseException { + final EvaluationInsertFormulaCommand.FormulaType type = isPredicate ? FormulaType.PREDICATE + : FormulaType.EXPRESSION; + final EvaluationElement evaluationElement = EvaluationInsertFormulaCommand + .insertFormula(animator, type, expressionStr); + return evaluationElement; + } + + public Map<String, Operation> getCurrentStateOperations() { + return currentStateOperations; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/BControlPropertySource.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/BControlPropertySource.java index 17f1924250af878c695bb46dbe39d443bc28f249..6d27311b8678f8f2221bfa912dbdaa9f2743f383 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/BControlPropertySource.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/BControlPropertySource.java @@ -1,70 +1,70 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import org.eclipse.ui.views.properties.PropertyDescriptor; - -import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; -import de.bmotionstudio.gef.editor.attribute.BAttributeMisc; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BControlPropertySource extends AbstractAttribute { - - private BControl control; - - private BAttributeMisc miscAttribute; - - public BControlPropertySource(BControl control) { - super(null); - this.control = control; - this.miscAttribute = new BAttributeMisc(null); - addChild(this.miscAttribute); - init(); - } - - private void init() { - - for (AbstractAttribute atr : control.getAttributes().values()) { - - atr.setControl(control); - - String group = atr.getGroup(); - - if (group != null) { - - // If group is root node --> add to root - if (group.equals(ROOT)) { - addChild(atr); - } else { - AbstractAttribute groupAtr = control.getAttribute(group); - if (groupAtr != null) { - groupAtr.addChild(atr); - } else { - miscAttribute.addChild(atr); - } - } - - } else { - // No group, add to misc attribute node - miscAttribute.addChild(atr); - } - - } - - } - - @Override - protected PropertyDescriptor preparePropertyDescriptor() { - return null; - } - - @Override - public String getName() { - return "RootProperties"; - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import org.eclipse.ui.views.properties.PropertyDescriptor; + +import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; +import de.bmotionstudio.gef.editor.attribute.BAttributeMisc; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BControlPropertySource extends AbstractAttribute { + + private BControl control; + + private BAttributeMisc miscAttribute; + + public BControlPropertySource(BControl control) { + super(null); + this.control = control; + this.miscAttribute = new BAttributeMisc(null); + addChild(this.miscAttribute); + init(); + } + + private void init() { + + for (AbstractAttribute atr : control.getAttributes().values()) { + + atr.setControl(control); + + String group = atr.getGroup(); + + if (group != null) { + + // If group is root node --> add to root + if (group.equals(ROOT)) { + addChild(atr); + } else { + AbstractAttribute groupAtr = control.getAttribute(group); + if (groupAtr != null) { + groupAtr.addChild(atr); + } else { + miscAttribute.addChild(atr); + } + } + + } else { + // No group, add to misc attribute node + miscAttribute.addChild(atr); + } + + } + + } + + @Override + protected PropertyDescriptor preparePropertyDescriptor() { + return null; + } + + @Override + public String getName() { + return "RootProperties"; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectAction.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectAction.java index 8144c6734f46d6372a9d5bbd4903a65706899450..414d011ed9919fb863a0f44ffb4c47003d703777 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectAction.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectAction.java @@ -1,78 +1,78 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.viewers.ISelection; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.wizard.WizardDialog; -import org.eclipse.ui.IActionDelegate; -import org.eclipse.ui.IObjectActionDelegate; -import org.eclipse.ui.IWorkbenchPart; -import org.rodinp.core.IRodinProject; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; - -@Deprecated -public class NewBMotionProjectAction implements IObjectActionDelegate { - - // private IWorkbenchPart targetPart; - private IStructuredSelection currentSelection; - private IRodinProject rodinProject; - - public NewBMotionProjectAction() { - super(); - } - - /** - * @see IObjectActionDelegate#setActivePart(IAction, IWorkbenchPart) - */ - public void setActivePart(final IAction action, - final IWorkbenchPart targetPart) { - // this.targetPart = targetPart; - } - - /** - * @see IActionDelegate#run(IAction) - */ - public void run(IAction action) { - - if (rodinProject == null) { - return; - } - - NewBMotionProjectWizard wizard = new NewBMotionProjectWizard(); - wizard.init(BMotionEditorPlugin.getDefault().getWorkbench(), - currentSelection); - WizardDialog dialog = new WizardDialog(BMotionEditorPlugin - .getActiveEditor().getSite().getShell(), wizard); - dialog.create(); - dialog.open(); - - } - - /** - * @see IActionDelegate#selectionChanged(IAction, ISelection) - */ - public void selectionChanged(IAction action, ISelection selection) { - - if (selection instanceof IStructuredSelection) { - IStructuredSelection ssel = (IStructuredSelection) selection; - currentSelection = ssel; - if (ssel.size() == 1) { - Object firstElement = ssel.getFirstElement(); - if (firstElement instanceof IRodinProject) { - rodinProject = (IRodinProject) firstElement; - return; - } - } - } - rodinProject = null; - - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.wizard.WizardDialog; +import org.eclipse.ui.IActionDelegate; +import org.eclipse.ui.IObjectActionDelegate; +import org.eclipse.ui.IWorkbenchPart; +import org.rodinp.core.IRodinProject; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; + +@Deprecated +public class NewBMotionProjectAction implements IObjectActionDelegate { + + // private IWorkbenchPart targetPart; + private IStructuredSelection currentSelection; + private IRodinProject rodinProject; + + public NewBMotionProjectAction() { + super(); + } + + /** + * @see IObjectActionDelegate#setActivePart(IAction, IWorkbenchPart) + */ + public void setActivePart(final IAction action, + final IWorkbenchPart targetPart) { + // this.targetPart = targetPart; + } + + /** + * @see IActionDelegate#run(IAction) + */ + public void run(IAction action) { + + if (rodinProject == null) { + return; + } + + NewBMotionProjectWizard wizard = new NewBMotionProjectWizard(); + wizard.init(BMotionEditorPlugin.getDefault().getWorkbench(), + currentSelection); + WizardDialog dialog = new WizardDialog(BMotionEditorPlugin + .getActiveEditor().getSite().getShell(), wizard); + dialog.create(); + dialog.open(); + + } + + /** + * @see IActionDelegate#selectionChanged(IAction, ISelection) + */ + public void selectionChanged(IAction action, ISelection selection) { + + if (selection instanceof IStructuredSelection) { + IStructuredSelection ssel = (IStructuredSelection) selection; + currentSelection = ssel; + if (ssel.size() == 1) { + Object firstElement = ssel.getFirstElement(); + if (firstElement instanceof IRodinProject) { + rodinProject = (IRodinProject) firstElement; + return; + } + } + } + rodinProject = null; + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizard.java index c43736ade824237727c41f35825e477f76d8c0b6..ae7689f1420914eb61a023b05dd64ce66467e40a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizard.java @@ -1,140 +1,140 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import java.io.InputStream; -import java.io.UnsupportedEncodingException; -import java.lang.reflect.InvocationTargetException; -import java.util.logging.Level; -import java.util.logging.Logger; - -import org.eclipse.core.resources.IContainer; -import org.eclipse.core.resources.IFile; -import org.eclipse.core.resources.IProject; -import org.eclipse.core.resources.IResource; -import org.eclipse.core.resources.IWorkspaceRoot; -import org.eclipse.core.resources.IWorkspaceRunnable; -import org.eclipse.core.resources.ResourcesPlugin; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IProgressMonitor; -import org.eclipse.core.runtime.IStatus; -import org.eclipse.core.runtime.Path; -import org.eclipse.core.runtime.Status; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.jface.operation.IRunnableWithProgress; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.wizard.Wizard; -import org.eclipse.ui.INewWizard; -import org.eclipse.ui.IWorkbench; -import org.rodinp.core.RodinCore; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; - -public class NewBMotionProjectWizard extends Wizard implements INewWizard { - - // The wizard page. - private NewBMotionProjectWizardPage page; - - // The selection when the wizard is launched. - private IStructuredSelection selection; - - public NewBMotionProjectWizard() { - super(); - setNeedsProgressMonitor(true); - } - - @Override - public void addPages() { - page = new NewBMotionProjectWizardPage(selection); - addPage(page); - } - - public void init(final IWorkbench workbench, final IStructuredSelection sel) { - this.selection = sel; - } - - @Override - public boolean performFinish() { - - // New project/file name - final String projectName = page.getFileName(); - - // Selected rodin project root - final String projectRoot = page.getProjectRoot(); - - final IRunnableWithProgress op = new IRunnableWithProgress() { - public void run(final IProgressMonitor monitor) - throws InvocationTargetException { - try { - doFinish( - projectRoot, - projectName, - page.getProject(), - page.getInitialContents(BMotionEditorPlugin.FILEEXT_STUDIO), - monitor); - } catch (final CoreException e) { - Logger.getAnonymousLogger().log(Level.SEVERE, - "CoreException", e); - } catch (UnsupportedEncodingException e) { - Logger.getAnonymousLogger().log(Level.SEVERE, - "CoreException", e); - } finally { - monitor.done(); - } - } - - }; - try { - getContainer().run(true, false, op); - } catch (final InterruptedException e) { - return false; - } catch (final InvocationTargetException e) { - final Throwable realException = e.getTargetException(); - MessageDialog.openError(getShell(), "Error", - realException.getMessage()); - return false; - } - - return true; - } - - private void doFinish(String projectRoot, final String projectName, - final IProject project, final InputStream defaultContentStudio, - final IProgressMonitor monitor) throws CoreException { - - monitor.beginTask("Creating " + projectName - + " BMotion Studio Visualization", 2); - - IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); - IResource resource = root.findMember(new Path(projectRoot)); - if (!resource.exists() || !(resource instanceof IContainer)) { - throw new CoreException(new Status(IStatus.ERROR, - "org.eventb.internal.ui", IStatus.OK, "Project \"" - + projectRoot + "\" does not exist.", null)); - } - - RodinCore.run(new IWorkspaceRunnable() { - - public void run(final IProgressMonitor pMonitor) - throws CoreException { - - // Create .bmso file - IFile file = project.getFile(projectName + "." - + BMotionEditorPlugin.FILEEXT_STUDIO); - - file.create(defaultContentStudio, false, monitor); - file.refreshLocal(IResource.DEPTH_ZERO, null); - - } - - }, monitor); - - monitor.worked(1); - - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import java.io.InputStream; +import java.io.UnsupportedEncodingException; +import java.lang.reflect.InvocationTargetException; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.eclipse.core.resources.IContainer; +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IResource; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.IWorkspaceRunnable; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Status; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.operation.IRunnableWithProgress; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.wizard.Wizard; +import org.eclipse.ui.INewWizard; +import org.eclipse.ui.IWorkbench; +import org.rodinp.core.RodinCore; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; + +public class NewBMotionProjectWizard extends Wizard implements INewWizard { + + // The wizard page. + private NewBMotionProjectWizardPage page; + + // The selection when the wizard is launched. + private IStructuredSelection selection; + + public NewBMotionProjectWizard() { + super(); + setNeedsProgressMonitor(true); + } + + @Override + public void addPages() { + page = new NewBMotionProjectWizardPage(selection); + addPage(page); + } + + public void init(final IWorkbench workbench, final IStructuredSelection sel) { + this.selection = sel; + } + + @Override + public boolean performFinish() { + + // New project/file name + final String projectName = page.getFileName(); + + // Selected rodin project root + final String projectRoot = page.getProjectRoot(); + + final IRunnableWithProgress op = new IRunnableWithProgress() { + public void run(final IProgressMonitor monitor) + throws InvocationTargetException { + try { + doFinish( + projectRoot, + projectName, + page.getProject(), + page.getInitialContents(BMotionEditorPlugin.FILEEXT_STUDIO), + monitor); + } catch (final CoreException e) { + Logger.getAnonymousLogger().log(Level.SEVERE, + "CoreException", e); + } catch (UnsupportedEncodingException e) { + Logger.getAnonymousLogger().log(Level.SEVERE, + "CoreException", e); + } finally { + monitor.done(); + } + } + + }; + try { + getContainer().run(true, false, op); + } catch (final InterruptedException e) { + return false; + } catch (final InvocationTargetException e) { + final Throwable realException = e.getTargetException(); + MessageDialog.openError(getShell(), "Error", + realException.getMessage()); + return false; + } + + return true; + } + + private void doFinish(String projectRoot, final String projectName, + final IProject project, final InputStream defaultContentStudio, + final IProgressMonitor monitor) throws CoreException { + + monitor.beginTask("Creating " + projectName + + " BMotion Studio Visualization", 2); + + IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); + IResource resource = root.findMember(new Path(projectRoot)); + if (!resource.exists() || !(resource instanceof IContainer)) { + throw new CoreException(new Status(IStatus.ERROR, + "org.eventb.internal.ui", IStatus.OK, "Project \"" + + projectRoot + "\" does not exist.", null)); + } + + RodinCore.run(new IWorkspaceRunnable() { + + public void run(final IProgressMonitor pMonitor) + throws CoreException { + + // Create .bmso file + IFile file = project.getFile(projectName + "." + + BMotionEditorPlugin.FILEEXT_STUDIO); + + file.create(defaultContentStudio, false, monitor); + file.refreshLocal(IResource.DEPTH_ZERO, null); + + } + + }, monitor); + + monitor.worked(1); + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizardPage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizardPage.java index f746da1abb0feb174bc38aee9c89525a94e26c65..8f5a952055d138b223e112d8a46806d46d763f8d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizardPage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/NewBMotionProjectWizardPage.java @@ -1,416 +1,416 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.InputStream; -import java.io.UnsupportedEncodingException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; -import java.util.Map.Entry; - -import org.eclipse.core.resources.IFile; -import org.eclipse.core.resources.IProject; -import org.eclipse.core.resources.ResourcesPlugin; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.IPath; -import org.eclipse.core.runtime.Path; -import org.eclipse.core.runtime.Platform; -import org.eclipse.jface.viewers.ArrayContentProvider; -import org.eclipse.jface.viewers.ISelectionChangedListener; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.ITableLabelProvider; -import org.eclipse.jface.viewers.LabelProvider; -import org.eclipse.jface.viewers.SelectionChangedEvent; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.window.Window; -import org.eclipse.jface.wizard.WizardPage; -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.ModifyEvent; -import org.eclipse.swt.events.ModifyListener; -import org.eclipse.swt.events.SelectionAdapter; -import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Button; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Label; -import org.eclipse.swt.widgets.Table; -import org.eclipse.swt.widgets.TableColumn; -import org.eclipse.swt.widgets.Text; -import org.eclipse.ui.dialogs.ContainerSelectionDialog; - -import com.thoughtworks.xstream.XStream; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.BMotionStudioImage; -import de.bmotionstudio.gef.editor.ILanguageService; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class NewBMotionProjectWizardPage extends WizardPage { - - private static final String DEFAULT_PROJECT_NAME = "NewBMotionVisualization"; - - private IProject selectedProject; - private final MachineList machineList = new MachineList(); - - private MachineEntry selectedEntry = null; - private Text projectRootText; - private Text projectText; - private TableViewer tableViewer; - - private Map<String, ILanguageService> languages = new HashMap<String, ILanguageService>(); - - protected NewBMotionProjectWizardPage(IStructuredSelection selection) { - super("wizardPage"); - this.selectedProject = getSelectedFromSelection(selection); - setTitle("New BMotion Studio Visualization"); - setDescription("Please select a B-Machine and enter a name for the new BMotion Studio Visualization."); - setImageDescriptor(BMotionStudioImage - .getImageDescriptor("icons/logo_bmotion_64.png")); - initLanguageExtensions(); - } - - private void initLanguageExtensions() { - // Get language loader - IExtensionRegistry registry = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.language"); - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - try { - ILanguageService lang = (ILanguageService) configurationElement - .createExecutableExtension("service"); - languages - .put(configurationElement.getAttribute("id"), lang); - } catch (CoreException e) { - e.printStackTrace(); - } - - } - } - } - - private IProject getSelectedFromSelection(IStructuredSelection selection) { - if (selection.size() == 1) { - Object firstElement = selection.getFirstElement(); - if (firstElement instanceof IProject) { - return (IProject) firstElement; - } - } - return null; - } - - public IProject getProject() { - return selectedProject; - } - - public InputStream getInitialContents(String fileExtension) - throws UnsupportedEncodingException { - Visualization visualization = new Visualization(getSelectedEntry() - .getMachineFile().getName(), getSelectedEntry() - .getMachineLanguage(), Platform - .getBundle(BMotionEditorPlugin.PLUGIN_ID).getHeaders() - .get("Bundle-Version")); - XStream xstream = new XStream(); - BMotionEditorPlugin.setAliases(xstream); - String content = xstream.toXML(visualization); - return new ByteArrayInputStream(content.getBytes("UTF-8")); - } - - public String getFileName() { - if (projectText.getText().length() > 0) { - return projectText.getText(); - } - return DEFAULT_PROJECT_NAME; - } - - public MachineEntry getSelectedEntry() { - return this.selectedEntry; - } - - public String getProjectRoot() { - return this.projectRootText.getText(); - } - - public String getBMotionProjectName() { - return this.projectText.getText(); - } - - private void initContent() { - - machineList.clearList(); - - if (selectedProject != null) { - - String basePath = (selectedProject.getLocation().toString()) - .replace("file:", ""); - File dir = new File(basePath); - - for (File f : dir.listFiles()) { - - for (Entry<String, ILanguageService> e : languages.entrySet()) { - - String langID = e.getKey(); - ILanguageService langService = e.getValue(); - - IPath path = new Path(f.getAbsolutePath()); - IFile ifile = ResourcesPlugin.getWorkspace().getRoot() - .getFile(path); - if (langService.isLanguageFile(ifile)) { - machineList.addEntry(new MachineEntry(ifile, langID)); - } - - } - - } - - } - - tableViewer.setInput(machineList.getChildren()); - - } - - private boolean resourceExistsInProject(String resourceName) { - IFile f = selectedProject.getFile(resourceName + "." - + BMotionEditorPlugin.FILEEXT_STUDIO); - return f.exists(); - } - - public void validateInput() { - StringBuffer errorMessages = new StringBuffer(150); - - if (getProjectRoot().length() == 0) { - errorMessages.append("The Project name must not be empty.\n"); - } - - if (getBMotionProjectName().length() == 0) { - errorMessages - .append("The BMotion Studio Visualization filename must not be empty.\n"); - } - - // if (errorMessages.length() == 0) { - // rodinProject = RodinCore.getRodinDB().getRodinProject( - // getProjectRoot().replaceAll("/", "")); - // - // if (!rodinProject.exists()) { - // errorMessages.append("The Project '" + getProjectRoot() - // + "' does not exist.\n"); - // } - // } - - if (getSelectedEntry() == null) { - errorMessages.append("You have to select a Machine.\n"); - } - - if (errorMessages.length() == 0 - && resourceExistsInProject(getBMotionProjectName())) { - errorMessages - .append("The BMotion Studio Visualization filename must be unique in a project.\n"); - } - - if (errorMessages.length() > 0) { - setErrorMessage(errorMessages.toString()); - setPageComplete(false); - } else { - setErrorMessage(null); - setPageComplete(true); - } - } - - public void createControl(final Composite parent) { - final Composite container = new Composite(parent, SWT.NULL); - - final GridLayout layout = new GridLayout(); - container.setLayout(layout); - - layout.numColumns = 3; - layout.verticalSpacing = 20; - - setControl(container); - - final ModifyListener listener = new ModifyListener() { - public void modifyText(final ModifyEvent e) { - validateInput(); - } - }; - - GridData gd = new GridData(); - gd.horizontalAlignment = SWT.FILL; - gd.grabExcessHorizontalSpace = true; - - Label label = new Label(container, SWT.NULL); - label.setText("&Project name:"); - - projectRootText = new Text(container, SWT.BORDER | SWT.SINGLE); - projectRootText.setLayoutData(gd); - if (selectedProject != null) { - projectRootText.setText(selectedProject.getFullPath().toOSString()); - } - projectRootText.addModifyListener(listener); - - final Button button = new Button(container, SWT.NULL); - button.setText("Browse..."); - button.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(final SelectionEvent e) { - final ContainerSelectionDialog dialog = new ContainerSelectionDialog( - getShell(), ResourcesPlugin.getWorkspace().getRoot(), - false, "Select Project"); - if (dialog.open() == Window.OK) { - final Object[] result = dialog.getResult(); - if (result.length == 1) { - Path newPath = (Path) result[0]; - IProject newProject = selectedProject.getWorkspace() - .getRoot().getProject(newPath.toString()); - selectedProject = newProject; - initContent(); - projectRootText.setText(((Path) result[0]).toOSString()); - validateInput(); - } - } - } - }); - - label = new Label(container, SWT.NULL); - label.setText("&BMotion Studio Visualization filename:"); - - projectText = new Text(container, SWT.BORDER | SWT.SINGLE); - projectText.setText(DEFAULT_PROJECT_NAME); - projectText.setLayoutData(gd); - projectText.addModifyListener(listener); - - gd = new GridData(); - gd.verticalAlignment = SWT.BEGINNING; - gd.horizontalSpan = 3; - - label = new Label(container, SWT.NULL); - label.setText("&B-Machine:"); - label.setLayoutData(gd); - - gd = new GridData(GridData.FILL_VERTICAL); - gd.horizontalAlignment = SWT.FILL; - gd.grabExcessHorizontalSpace = true; - gd.horizontalSpan = 3; - - tableViewer = new TableViewer(container, SWT.SINGLE - | SWT.FULL_SELECTION); - final Table table = tableViewer.getTable(); - table.setHeaderVisible(true); - table.setLinesVisible(true); - table.setLayoutData(gd); - - final String[] columnsNames = new String[] { "Machine", "Language" }; - final int[] columnWidths = new int[] { 250, 100 }; - final int[] columnAlignments = new int[] { SWT.LEFT, SWT.LEFT }; - - for (int i = 0; i < columnsNames.length; i++) { - final TableColumn tableColumn = new TableColumn(table, - columnAlignments[i]); - tableColumn.setText(columnsNames[i]); - tableColumn.setWidth(columnWidths[i]); - } - - tableViewer.setLabelProvider(new MachineLabelProvider()); - tableViewer.setContentProvider(new ArrayContentProvider()); - initContent(); - - tableViewer - .addSelectionChangedListener(new ISelectionChangedListener() { - public void selectionChanged(SelectionChangedEvent event) { - IStructuredSelection selection = (IStructuredSelection) event - .getSelection(); - selectedEntry = (MachineEntry) selection - .getFirstElement(); - validateInput(); - } - }); - - validateInput(); - - } - - private static class MachineLabelProvider extends LabelProvider implements - ITableLabelProvider { - - public Image getColumnImage(final Object element, final int columnIndex) { - return null; - } - - public String getColumnText(final Object element, final int columnIndex) { - if (element instanceof MachineEntry) { - - final MachineEntry currentEntry = (MachineEntry) element; - - switch (columnIndex) { - case 0: - return currentEntry.getMachineName(); - case 1: - return currentEntry.getMachineLanguage(); - } - - } - - return null; - } - - } - - private static class MachineList { - private final ArrayList<MachineEntry> entries = new ArrayList<MachineEntry>(); - - public MachineEntry[] getChildren() { - return entries.toArray(new MachineEntry[entries.size()]); - } - - public void addEntry(final MachineEntry entry) { - if (!entries.contains(entry)) { - entries.add(entry); - } - } - - public void clearList() { - this.entries.clear(); - } - - } - - private static class MachineEntry { - - private final String machineName; - private final String machineLanguage; - private final IFile file; - - public MachineEntry(IFile file, String machineLanguage) { - this.file = file; - this.machineName = file.getName(); - this.machineLanguage = machineLanguage; - } - - public String getMachineName() { - return this.machineName; - } - - public String getMachineLanguage() { - return this.machineLanguage; - } - - public IFile getMachineFile() { - return this.file; - } - - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.InputStream; +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.Path; +import org.eclipse.core.runtime.Platform; +import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.ITableLabelProvider; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.window.Window; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.ModifyEvent; +import org.eclipse.swt.events.ModifyListener; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Table; +import org.eclipse.swt.widgets.TableColumn; +import org.eclipse.swt.widgets.Text; +import org.eclipse.ui.dialogs.ContainerSelectionDialog; + +import com.thoughtworks.xstream.XStream; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.BMotionStudioImage; +import de.bmotionstudio.gef.editor.ILanguageService; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class NewBMotionProjectWizardPage extends WizardPage { + + private static final String DEFAULT_PROJECT_NAME = "NewBMotionVisualization"; + + private IProject selectedProject; + private final MachineList machineList = new MachineList(); + + private MachineEntry selectedEntry = null; + private Text projectRootText; + private Text projectText; + private TableViewer tableViewer; + + private Map<String, ILanguageService> languages = new HashMap<String, ILanguageService>(); + + protected NewBMotionProjectWizardPage(IStructuredSelection selection) { + super("wizardPage"); + this.selectedProject = getSelectedFromSelection(selection); + setTitle("New BMotion Studio Visualization"); + setDescription("Please select a B-Machine and enter a name for the new BMotion Studio Visualization."); + setImageDescriptor(BMotionStudioImage + .getImageDescriptor("icons/logo_bmotion_64.png")); + initLanguageExtensions(); + } + + private void initLanguageExtensions() { + // Get language loader + IExtensionRegistry registry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.language"); + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + try { + ILanguageService lang = (ILanguageService) configurationElement + .createExecutableExtension("service"); + languages + .put(configurationElement.getAttribute("id"), lang); + } catch (CoreException e) { + e.printStackTrace(); + } + + } + } + } + + private IProject getSelectedFromSelection(IStructuredSelection selection) { + if (selection.size() == 1) { + Object firstElement = selection.getFirstElement(); + if (firstElement instanceof IProject) { + return (IProject) firstElement; + } + } + return null; + } + + public IProject getProject() { + return selectedProject; + } + + public InputStream getInitialContents(String fileExtension) + throws UnsupportedEncodingException { + Visualization visualization = new Visualization(getSelectedEntry() + .getMachineFile().getName(), getSelectedEntry() + .getMachineLanguage(), Platform + .getBundle(BMotionEditorPlugin.PLUGIN_ID).getHeaders() + .get("Bundle-Version")); + XStream xstream = new XStream(); + BMotionEditorPlugin.setAliases(xstream); + String content = xstream.toXML(visualization); + return new ByteArrayInputStream(content.getBytes("UTF-8")); + } + + public String getFileName() { + if (projectText.getText().length() > 0) { + return projectText.getText(); + } + return DEFAULT_PROJECT_NAME; + } + + public MachineEntry getSelectedEntry() { + return this.selectedEntry; + } + + public String getProjectRoot() { + return this.projectRootText.getText(); + } + + public String getBMotionProjectName() { + return this.projectText.getText(); + } + + private void initContent() { + + machineList.clearList(); + + if (selectedProject != null) { + + String basePath = (selectedProject.getLocation().toString()) + .replace("file:", ""); + File dir = new File(basePath); + + for (File f : dir.listFiles()) { + + for (Entry<String, ILanguageService> e : languages.entrySet()) { + + String langID = e.getKey(); + ILanguageService langService = e.getValue(); + + IPath path = new Path(f.getAbsolutePath()); + IFile ifile = ResourcesPlugin.getWorkspace().getRoot() + .getFile(path); + if (langService.isLanguageFile(ifile)) { + machineList.addEntry(new MachineEntry(ifile, langID)); + } + + } + + } + + } + + tableViewer.setInput(machineList.getChildren()); + + } + + private boolean resourceExistsInProject(String resourceName) { + IFile f = selectedProject.getFile(resourceName + "." + + BMotionEditorPlugin.FILEEXT_STUDIO); + return f.exists(); + } + + public void validateInput() { + StringBuffer errorMessages = new StringBuffer(150); + + if (getProjectRoot().length() == 0) { + errorMessages.append("The Project name must not be empty.\n"); + } + + if (getBMotionProjectName().length() == 0) { + errorMessages + .append("The BMotion Studio Visualization filename must not be empty.\n"); + } + + // if (errorMessages.length() == 0) { + // rodinProject = RodinCore.getRodinDB().getRodinProject( + // getProjectRoot().replaceAll("/", "")); + // + // if (!rodinProject.exists()) { + // errorMessages.append("The Project '" + getProjectRoot() + // + "' does not exist.\n"); + // } + // } + + if (getSelectedEntry() == null) { + errorMessages.append("You have to select a Machine.\n"); + } + + if (errorMessages.length() == 0 + && resourceExistsInProject(getBMotionProjectName())) { + errorMessages + .append("The BMotion Studio Visualization filename must be unique in a project.\n"); + } + + if (errorMessages.length() > 0) { + setErrorMessage(errorMessages.toString()); + setPageComplete(false); + } else { + setErrorMessage(null); + setPageComplete(true); + } + } + + public void createControl(final Composite parent) { + final Composite container = new Composite(parent, SWT.NULL); + + final GridLayout layout = new GridLayout(); + container.setLayout(layout); + + layout.numColumns = 3; + layout.verticalSpacing = 20; + + setControl(container); + + final ModifyListener listener = new ModifyListener() { + public void modifyText(final ModifyEvent e) { + validateInput(); + } + }; + + GridData gd = new GridData(); + gd.horizontalAlignment = SWT.FILL; + gd.grabExcessHorizontalSpace = true; + + Label label = new Label(container, SWT.NULL); + label.setText("&Project name:"); + + projectRootText = new Text(container, SWT.BORDER | SWT.SINGLE); + projectRootText.setLayoutData(gd); + if (selectedProject != null) { + projectRootText.setText(selectedProject.getFullPath().toOSString()); + } + projectRootText.addModifyListener(listener); + + final Button button = new Button(container, SWT.NULL); + button.setText("Browse..."); + button.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(final SelectionEvent e) { + final ContainerSelectionDialog dialog = new ContainerSelectionDialog( + getShell(), ResourcesPlugin.getWorkspace().getRoot(), + false, "Select Project"); + if (dialog.open() == Window.OK) { + final Object[] result = dialog.getResult(); + if (result.length == 1) { + Path newPath = (Path) result[0]; + IProject newProject = selectedProject.getWorkspace() + .getRoot().getProject(newPath.toString()); + selectedProject = newProject; + initContent(); + projectRootText.setText(((Path) result[0]).toOSString()); + validateInput(); + } + } + } + }); + + label = new Label(container, SWT.NULL); + label.setText("&BMotion Studio Visualization filename:"); + + projectText = new Text(container, SWT.BORDER | SWT.SINGLE); + projectText.setText(DEFAULT_PROJECT_NAME); + projectText.setLayoutData(gd); + projectText.addModifyListener(listener); + + gd = new GridData(); + gd.verticalAlignment = SWT.BEGINNING; + gd.horizontalSpan = 3; + + label = new Label(container, SWT.NULL); + label.setText("&B-Machine:"); + label.setLayoutData(gd); + + gd = new GridData(GridData.FILL_VERTICAL); + gd.horizontalAlignment = SWT.FILL; + gd.grabExcessHorizontalSpace = true; + gd.horizontalSpan = 3; + + tableViewer = new TableViewer(container, SWT.SINGLE + | SWT.FULL_SELECTION); + final Table table = tableViewer.getTable(); + table.setHeaderVisible(true); + table.setLinesVisible(true); + table.setLayoutData(gd); + + final String[] columnsNames = new String[] { "Machine", "Language" }; + final int[] columnWidths = new int[] { 250, 100 }; + final int[] columnAlignments = new int[] { SWT.LEFT, SWT.LEFT }; + + for (int i = 0; i < columnsNames.length; i++) { + final TableColumn tableColumn = new TableColumn(table, + columnAlignments[i]); + tableColumn.setText(columnsNames[i]); + tableColumn.setWidth(columnWidths[i]); + } + + tableViewer.setLabelProvider(new MachineLabelProvider()); + tableViewer.setContentProvider(new ArrayContentProvider()); + initContent(); + + tableViewer + .addSelectionChangedListener(new ISelectionChangedListener() { + public void selectionChanged(SelectionChangedEvent event) { + IStructuredSelection selection = (IStructuredSelection) event + .getSelection(); + selectedEntry = (MachineEntry) selection + .getFirstElement(); + validateInput(); + } + }); + + validateInput(); + + } + + private static class MachineLabelProvider extends LabelProvider implements + ITableLabelProvider { + + public Image getColumnImage(final Object element, final int columnIndex) { + return null; + } + + public String getColumnText(final Object element, final int columnIndex) { + if (element instanceof MachineEntry) { + + final MachineEntry currentEntry = (MachineEntry) element; + + switch (columnIndex) { + case 0: + return currentEntry.getMachineName(); + case 1: + return currentEntry.getMachineLanguage(); + } + + } + + return null; + } + + } + + private static class MachineList { + private final ArrayList<MachineEntry> entries = new ArrayList<MachineEntry>(); + + public MachineEntry[] getChildren() { + return entries.toArray(new MachineEntry[entries.size()]); + } + + public void addEntry(final MachineEntry entry) { + if (!entries.contains(entry)) { + entries.add(entry); + } + } + + public void clearList() { + this.entries.clear(); + } + + } + + private static class MachineEntry { + + private final String machineName; + private final String machineLanguage; + private final IFile file; + + public MachineEntry(IFile file, String machineLanguage) { + this.file = file; + this.machineName = file.getName(); + this.machineLanguage = machineLanguage; + } + + public String getMachineName() { + return this.machineName; + } + + public String getMachineLanguage() { + return this.machineLanguage; + } + + public IFile getMachineFile() { + return this.file; + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/PerspectiveEditFactory.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/PerspectiveEditFactory.java index 2603fee362ae80c07df25e5b1caf8e9e4f367193..cbef8d7e70d7766dbe2afcffd33e753470dba99b 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/PerspectiveEditFactory.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/PerspectiveEditFactory.java @@ -1,43 +1,43 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import org.eclipse.ui.IFolderLayout; -import org.eclipse.ui.IPageLayout; -import org.eclipse.ui.IPerspectiveFactory; - -import de.bmotionstudio.gef.editor.library.LibraryView; - -public class PerspectiveEditFactory implements IPerspectiveFactory { - - public void createInitialLayout(final IPageLayout layout) { - - final String editorArea = layout.getEditorArea(); - - // Place the project explorer to left of editor area. - final IFolderLayout left = layout.createFolder("left", - IPageLayout.LEFT, 0.15f, editorArea); - left.addView("fr.systerel.explorer.navigator.view"); - - // Place the outline to right of editor area. - final IFolderLayout righttop = layout.createFolder("right", - IPageLayout.RIGHT, 0.8f, editorArea); - righttop.addView(IPageLayout.ID_OUTLINE); - - // Library view - final IFolderLayout rightbot = layout.createFolder("rightb", - IPageLayout.BOTTOM, 0.6f, "right"); - rightbot.addView(LibraryView.ID); - - final IFolderLayout bottom = layout.createFolder("bottom", - IPageLayout.BOTTOM, 0.75f, editorArea); - // Properties view - bottom.addView(IPageLayout.ID_PROP_SHEET); - - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import org.eclipse.ui.IFolderLayout; +import org.eclipse.ui.IPageLayout; +import org.eclipse.ui.IPerspectiveFactory; + +import de.bmotionstudio.gef.editor.library.LibraryView; + +public class PerspectiveEditFactory implements IPerspectiveFactory { + + public void createInitialLayout(final IPageLayout layout) { + + final String editorArea = layout.getEditorArea(); + + // Place the project explorer to left of editor area. + final IFolderLayout left = layout.createFolder("left", + IPageLayout.LEFT, 0.15f, editorArea); + left.addView("fr.systerel.explorer.navigator.view"); + + // Place the outline to right of editor area. + final IFolderLayout righttop = layout.createFolder("right", + IPageLayout.RIGHT, 0.8f, editorArea); + righttop.addView(IPageLayout.ID_OUTLINE); + + // Library view + final IFolderLayout rightbot = layout.createFolder("rightb", + IPageLayout.BOTTOM, 0.6f, "right"); + rightbot.addView(LibraryView.ID); + + final IFolderLayout bottom = layout.createFolder("bottom", + IPageLayout.BOTTOM, 0.75f, editorArea); + // Properties view + bottom.addView(IPageLayout.ID_PROP_SHEET); + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/RenameWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/RenameWizard.java index c9897d93d068dcbd6e9a43d80444ebfca24ae0c7..117a244f3aa03bc54f91db884197286d6d49db1b 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/RenameWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/RenameWizard.java @@ -1,72 +1,72 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import org.eclipse.jface.wizard.Wizard; -import org.eclipse.jface.wizard.WizardPage; -import org.eclipse.swt.SWT; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Label; -import org.eclipse.swt.widgets.Text; - -public class RenameWizard extends Wizard { - - private class RenamePage extends WizardPage { - - public Text nameText; - - public RenamePage(final String pageName) { - super(pageName); - setTitle("BMotion Studio Rename Wizard"); - setDescription("Rename a control"); - } - - public void createControl(final Composite parent) { - - Composite composite = new Composite(parent, SWT.NONE); - composite.setLayout(new GridLayout(2, false)); - - Label lab = new Label(composite, SWT.NONE); - lab.setText("Rename to: "); - lab.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); - - GridData gd = new GridData(GridData.FILL_HORIZONTAL); - gd.heightHint = 90; - - nameText = new Text(composite, SWT.BORDER | SWT.WRAP | SWT.V_SCROLL); - nameText.setText(oldName); - nameText.setLayoutData(gd); - - setControl(composite); - - } - - } - - private final String oldName; - private String newName; - - public RenameWizard(final String oldName) { - this.oldName = oldName; - this.newName = null; - addPage(new RenamePage("MyRenamePage")); - } - - @Override - public boolean performFinish() { - RenamePage page = (RenamePage) getPage("MyRenamePage"); - newName = page.nameText.getText(); - return true; - } - - public String getRenameValue() { - return newName; - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import org.eclipse.jface.wizard.Wizard; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Text; + +public class RenameWizard extends Wizard { + + private class RenamePage extends WizardPage { + + public Text nameText; + + public RenamePage(final String pageName) { + super(pageName); + setTitle("BMotion Studio Rename Wizard"); + setDescription("Rename a control"); + } + + public void createControl(final Composite parent) { + + Composite composite = new Composite(parent, SWT.NONE); + composite.setLayout(new GridLayout(2, false)); + + Label lab = new Label(composite, SWT.NONE); + lab.setText("Rename to: "); + lab.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); + + GridData gd = new GridData(GridData.FILL_HORIZONTAL); + gd.heightHint = 90; + + nameText = new Text(composite, SWT.BORDER | SWT.WRAP | SWT.V_SCROLL); + nameText.setText(oldName); + nameText.setLayoutData(gd); + + setControl(composite); + + } + + } + + private final String oldName; + private String newName; + + public RenameWizard(final String oldName) { + this.oldName = oldName; + this.newName = null; + addPage(new RenamePage("MyRenamePage")); + } + + @Override + public boolean performFinish() { + RenamePage page = (RenamePage) getPage("MyRenamePage"); + newName = page.nameText.getText(); + return true; + } + + public String getRenameValue() { + return newName; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/SelectOperationDialog.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/SelectOperationDialog.java index ae9aaf655a6695f08182f17fc4b5e5791aaacc1c..3f65f2ac5918321df5b2915b28c36e599aee679d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/SelectOperationDialog.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/SelectOperationDialog.java @@ -1,105 +1,105 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import java.util.List; - -import org.eclipse.jface.dialogs.Dialog; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.jface.viewers.ArrayContentProvider; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.ListViewer; -import org.eclipse.swt.SWT; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Label; -import org.eclipse.swt.widgets.Shell; - -import de.prob.core.domainobjects.Operation; - -public class SelectOperationDialog extends Dialog { - - private List<Operation> ops; - private Operation selectedOperation; - // private ComboViewer cb; - private ListViewer listViewer; - - protected SelectOperationDialog(Shell parentShell, List<Operation> ops) { - super(parentShell); - this.ops = ops; - } - - @Override - protected Control createDialogArea(Composite parent) { - Composite container = (Composite) super.createDialogArea(parent); - - GridLayout gl = new GridLayout(2, false); - gl.marginLeft = 15; - gl.marginTop = 20; - - container.setLayout(gl); - - Label lb = new Label(container, SWT.NONE); - lb.setText("Select an operation:"); - lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); - - listViewer = new ListViewer(container); - listViewer.setContentProvider(new ArrayContentProvider()); - listViewer.setInput(ops); - listViewer.getList().setLayoutData(new GridData(GridData.FILL_BOTH)); - - // cb = new ComboViewer(container, SWT.NONE); - // cb.setContentProvider(new ArrayContentProvider()); - // cb.setInput(ops); - // cb.getCombo().setLayoutData(new GridData(200, 20)); - // cb.getCombo() - // .setFont( - // JFaceResources.getFontRegistry().get( - // BasicUtils.RODIN_FONT_KEY)); - - return container; - - } - - @Override - protected void configureShell(Shell newShell) { - super.configureShell(newShell); - newShell.setText("Please select an operation ..."); - } - - @Override - protected Point getInitialSize() { - return new Point(600, 250); - } - - @Override - protected void okPressed() { - - IStructuredSelection selection = (IStructuredSelection) listViewer - .getSelection(); - selectedOperation = (Operation) selection.getFirstElement(); - - if (selectedOperation == null) { - MessageDialog.openError(Display.getDefault().getActiveShell(), - "An error occurred", "Please select an operation ..."); - return; - } else { - setReturnCode(OK); - close(); - } - - } - - public Operation getSelectedOperation() { - return this.selectedOperation; - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +import java.util.List; + +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.ListViewer; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Shell; + +import de.prob.core.domainobjects.Operation; + +public class SelectOperationDialog extends Dialog { + + private List<Operation> ops; + private Operation selectedOperation; + // private ComboViewer cb; + private ListViewer listViewer; + + protected SelectOperationDialog(Shell parentShell, List<Operation> ops) { + super(parentShell); + this.ops = ops; + } + + @Override + protected Control createDialogArea(Composite parent) { + Composite container = (Composite) super.createDialogArea(parent); + + GridLayout gl = new GridLayout(2, false); + gl.marginLeft = 15; + gl.marginTop = 20; + + container.setLayout(gl); + + Label lb = new Label(container, SWT.NONE); + lb.setText("Select an operation:"); + lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); + + listViewer = new ListViewer(container); + listViewer.setContentProvider(new ArrayContentProvider()); + listViewer.setInput(ops); + listViewer.getList().setLayoutData(new GridData(GridData.FILL_BOTH)); + + // cb = new ComboViewer(container, SWT.NONE); + // cb.setContentProvider(new ArrayContentProvider()); + // cb.setInput(ops); + // cb.getCombo().setLayoutData(new GridData(200, 20)); + // cb.getCombo() + // .setFont( + // JFaceResources.getFontRegistry().get( + // BasicUtils.RODIN_FONT_KEY)); + + return container; + + } + + @Override + protected void configureShell(Shell newShell) { + super.configureShell(newShell); + newShell.setText("Please select an operation ..."); + } + + @Override + protected Point getInitialSize() { + return new Point(600, 250); + } + + @Override + protected void okPressed() { + + IStructuredSelection selection = (IStructuredSelection) listViewer + .getSelection(); + selectedOperation = (Operation) selection.getFirstElement(); + + if (selectedOperation == null) { + MessageDialog.openError(Display.getDefault().getActiveShell(), + "An error occurred", "Please select an operation ..."); + return; + } else { + setReturnCode(OK); + close(); + } + + } + + public Operation getSelectedOperation() { + return this.selectedOperation; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationEditorHandler.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationEditorHandler.java index d372e4d5435629678eb967c5a9a0564cde5ff4fc..bda5ba1df2ffa63f35d858a5a86fc205ea6372ba 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationEditorHandler.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationEditorHandler.java @@ -1,73 +1,73 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -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.runtime.NullProgressMonitor; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.swt.widgets.Display; -import org.eclipse.ui.IWorkbench; -import org.eclipse.ui.PlatformUI; -import org.eclipse.ui.WorkbenchException; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.prob.core.Animator; -import de.prob.logging.Logger; - -public class StartVisualizationEditorHandler extends AbstractHandler implements - IHandler { - - private VisualizationProgressBar dpb; - - public Object execute(final ExecutionEvent event) throws ExecutionException { - - if (BMotionEditorPlugin.getActiveEditor().isDirty()) { - if (MessageDialog - .openConfirm( - Display.getDefault().getActiveShell(), - "Please confirm", - "You made changes in your editor. Do you want to safe before starting visualization?")) { - BMotionEditorPlugin.getActiveEditor().doSave( - new NullProgressMonitor()); - } - } - - IFile projectFile = BMotionEditorPlugin.getActiveEditor() - .getVisualization().getProjectFile(); - - // Get ProB Animator - Animator animator = Animator.getAnimator(); - - // Open Run Perspective - IWorkbench workbench = PlatformUI.getWorkbench(); - try { - workbench.showPerspective("de.bmotionstudio.perspective.run", - workbench.getActiveWorkbenchWindow()); - } catch (WorkbenchException e) { - Logger.notifyUser("Error opening BMotion Studio Run perspective.", - e); - } - - // First, kill old visualization (only if exists) - if (dpb != null) - dpb.kill(); - // Create a new visualization - dpb = new VisualizationProgressBar(Display.getDefault() - .getActiveShell(), animator, - BMotionEditorPlugin.getActiveEditor(), projectFile); - dpb.initGuage(); - dpb.open(); - - return null; - - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +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.runtime.NullProgressMonitor; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.IWorkbench; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.WorkbenchException; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.prob.core.Animator; +import de.prob.logging.Logger; + +public class StartVisualizationEditorHandler extends AbstractHandler implements + IHandler { + + private VisualizationProgressBar dpb; + + public Object execute(final ExecutionEvent event) throws ExecutionException { + + if (BMotionEditorPlugin.getActiveEditor().isDirty()) { + if (MessageDialog + .openConfirm( + Display.getDefault().getActiveShell(), + "Please confirm", + "You made changes in your editor. Do you want to safe before starting visualization?")) { + BMotionEditorPlugin.getActiveEditor().doSave( + new NullProgressMonitor()); + } + } + + IFile projectFile = BMotionEditorPlugin.getActiveEditor() + .getVisualization().getProjectFile(); + + // Get ProB Animator + Animator animator = Animator.getAnimator(); + + // Open Run Perspective + IWorkbench workbench = PlatformUI.getWorkbench(); + try { + workbench.showPerspective("de.bmotionstudio.perspective.run", + workbench.getActiveWorkbenchWindow()); + } catch (WorkbenchException e) { + Logger.notifyUser("Error opening BMotion Studio Run perspective.", + e); + } + + // First, kill old visualization (only if exists) + if (dpb != null) + dpb.kill(); + // Create a new visualization + dpb = new VisualizationProgressBar(Display.getDefault() + .getActiveShell(), animator, + BMotionEditorPlugin.getActiveEditor(), projectFile); + dpb.initGuage(); + dpb.open(); + + return null; + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationFileHandler.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationFileHandler.java index 55a3f77554ff818a6757dd1b754b5dde26affb8f..2c9964a279dd5b4c08b830489ae060de8d64c7bf 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationFileHandler.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/StartVisualizationFileHandler.java @@ -1,135 +1,135 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -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.runtime.NullProgressMonitor; -import org.eclipse.jface.action.IAction; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.jface.viewers.ISelection; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.swt.widgets.Display; -import org.eclipse.ui.IEditorDescriptor; -import org.eclipse.ui.IEditorPart; -import org.eclipse.ui.IWorkbench; -import org.eclipse.ui.IWorkbenchPage; -import org.eclipse.ui.IWorkbenchWindow; -import org.eclipse.ui.PartInitException; -import org.eclipse.ui.PlatformUI; -import org.eclipse.ui.WorkbenchException; -import org.eclipse.ui.handlers.HandlerUtil; -import org.eclipse.ui.part.FileEditorInput; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.BMotionStudioEditor; -import de.prob.core.Animator; -import de.prob.logging.Logger; - -public class StartVisualizationFileHandler extends AbstractHandler implements - IHandler { - - private ISelection fSelection; - private VisualizationProgressBar dpb; - private BMotionStudioEditor activeEditor; - - public Object execute(final ExecutionEvent event) throws ExecutionException { - - fSelection = HandlerUtil.getCurrentSelection(event); - - BMotionStudioEditor editor = BMotionEditorPlugin.getActiveEditor(); - if (editor != null) { - if (BMotionEditorPlugin.getActiveEditor().isDirty()) { - if (MessageDialog - .openConfirm( - Display.getDefault().getActiveShell(), - "Please confirm", - "You made changes in your editor. Do you want to safe before starting visualization?")) { - - BMotionEditorPlugin.getActiveEditor().doSave( - new NullProgressMonitor()); - } - } - } - - IFile f = null; - - // Get the Selection - if (fSelection instanceof IStructuredSelection) { - - IStructuredSelection ssel = (IStructuredSelection) fSelection; - - if (ssel.size() == 1) { - - f = getBmsFileFromSelection(ssel); - - IWorkbenchWindow window = PlatformUI.getWorkbench() - .getActiveWorkbenchWindow(); - IWorkbenchPage page = window.getActivePage(); - - IEditorDescriptor desc = PlatformUI.getWorkbench() - .getEditorRegistry().getDefaultEditor(f.getName()); - - try { - IEditorPart part = page.openEditor(new FileEditorInput(f), - desc.getId()); - if (part instanceof BMotionStudioEditor) { - activeEditor = (BMotionStudioEditor) part; - } else { - // TODO: Return some useful error?! - return null; - } - } catch (PartInitException e) { - e.printStackTrace(); - } - - // Get ProB Animator - Animator animator = Animator.getAnimator(); - - // Open Run Perspective - IWorkbench workbench = PlatformUI.getWorkbench(); - try { - workbench.showPerspective( - "de.bmotionstudio.perspective.run", - workbench.getActiveWorkbenchWindow()); - } catch (WorkbenchException e) { - Logger.notifyUser( - "Error opening BMotion Studio Run perspective.", e); - } - - // First, kill old visualization (only if exists) - if (dpb != null) - dpb.kill(); - // Create a new visualization - dpb = new VisualizationProgressBar(Display.getDefault() - .getActiveShell(), animator, activeEditor, f); - dpb.initGuage(); - dpb.open(); - - } - - } - - return null; - - } - - public void selectionChanged(final IAction action, - final ISelection selection) { - fSelection = selection; - } - - protected IFile getBmsFileFromSelection(IStructuredSelection ssel) { - if (ssel.getFirstElement() instanceof IFile) - return (IFile) ssel.getFirstElement(); - return null; - } - -} +/** + * (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.bmotionstudio.gef.editor.internal; + +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.runtime.NullProgressMonitor; +import org.eclipse.jface.action.IAction; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.ISelection; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.swt.widgets.Display; +import org.eclipse.ui.IEditorDescriptor; +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IWorkbench; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.IWorkbenchWindow; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.PlatformUI; +import org.eclipse.ui.WorkbenchException; +import org.eclipse.ui.handlers.HandlerUtil; +import org.eclipse.ui.part.FileEditorInput; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.BMotionStudioEditor; +import de.prob.core.Animator; +import de.prob.logging.Logger; + +public class StartVisualizationFileHandler extends AbstractHandler implements + IHandler { + + private ISelection fSelection; + private VisualizationProgressBar dpb; + private BMotionStudioEditor activeEditor; + + public Object execute(final ExecutionEvent event) throws ExecutionException { + + fSelection = HandlerUtil.getCurrentSelection(event); + + BMotionStudioEditor editor = BMotionEditorPlugin.getActiveEditor(); + if (editor != null) { + if (BMotionEditorPlugin.getActiveEditor().isDirty()) { + if (MessageDialog + .openConfirm( + Display.getDefault().getActiveShell(), + "Please confirm", + "You made changes in your editor. Do you want to safe before starting visualization?")) { + + BMotionEditorPlugin.getActiveEditor().doSave( + new NullProgressMonitor()); + } + } + } + + IFile f = null; + + // Get the Selection + if (fSelection instanceof IStructuredSelection) { + + IStructuredSelection ssel = (IStructuredSelection) fSelection; + + if (ssel.size() == 1) { + + f = getBmsFileFromSelection(ssel); + + IWorkbenchWindow window = PlatformUI.getWorkbench() + .getActiveWorkbenchWindow(); + IWorkbenchPage page = window.getActivePage(); + + IEditorDescriptor desc = PlatformUI.getWorkbench() + .getEditorRegistry().getDefaultEditor(f.getName()); + + try { + IEditorPart part = page.openEditor(new FileEditorInput(f), + desc.getId()); + if (part instanceof BMotionStudioEditor) { + activeEditor = (BMotionStudioEditor) part; + } else { + // TODO: Return some useful error?! + return null; + } + } catch (PartInitException e) { + e.printStackTrace(); + } + + // Get ProB Animator + Animator animator = Animator.getAnimator(); + + // Open Run Perspective + IWorkbench workbench = PlatformUI.getWorkbench(); + try { + workbench.showPerspective( + "de.bmotionstudio.perspective.run", + workbench.getActiveWorkbenchWindow()); + } catch (WorkbenchException e) { + Logger.notifyUser( + "Error opening BMotion Studio Run perspective.", e); + } + + // First, kill old visualization (only if exists) + if (dpb != null) + dpb.kill(); + // Create a new visualization + dpb = new VisualizationProgressBar(Display.getDefault() + .getActiveShell(), animator, activeEditor, f); + dpb.initGuage(); + dpb.open(); + + } + + } + + return null; + + } + + public void selectionChanged(final IAction action, + final ISelection selection) { + fSelection = selection; + } + + protected IFile getBmsFileFromSelection(IStructuredSelection ssel) { + if (ssel.getFirstElement() instanceof IFile) + return (IFile) ssel.getFirstElement(); + return null; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/VisualizationProgressBar.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/VisualizationProgressBar.java index 549adbd74d032783c1c88f1a5a16ee82b0482c4b..2bddb21f39064908ae7dcae5856c5fca63877792 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/VisualizationProgressBar.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/internal/VisualizationProgressBar.java @@ -1,288 +1,288 @@ -/** - * (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.bmotionstudio.gef.editor.internal; - -import java.io.IOException; -import java.util.List; -import java.util.Locale; - -import javax.xml.parsers.ParserConfigurationException; - -import org.eclipse.core.resources.IFile; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.core.runtime.IExtension; -import org.eclipse.core.runtime.IExtensionPoint; -import org.eclipse.core.runtime.IExtensionRegistry; -import org.eclipse.core.runtime.IStatus; -import org.eclipse.core.runtime.Platform; -import org.eclipse.core.runtime.Status; -import org.eclipse.jface.dialogs.ErrorDialog; -import org.eclipse.jface.window.Window; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; -import org.xml.sax.SAXException; - -import com.thoughtworks.xstream.XStream; -import com.thoughtworks.xstream.io.xml.DomDriver; -import com.thoughtworks.xstream.mapper.MapperWrapper; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.BMotionStudioEditor; -import de.bmotionstudio.gef.editor.ILanguageService; -import de.bmotionstudio.gef.editor.model.Visualization; -import de.prob.core.Animator; -import de.prob.core.command.ExecuteOperationCommand; -import de.prob.core.domainobjects.Operation; -import de.prob.exceptions.ProBException; - -public class VisualizationProgressBar extends ProgressBarDialog { - - private Animator animator; - private IFile f; - private Visualization visualization; - private Animation animation; - private int confirm = -1; - private SelectOperationDialog dialog; - private BMotionStudioEditor activeEditor; - - public VisualizationProgressBar(Shell parent, Animator animator, - BMotionStudioEditor activeEditor, IFile f) { - super(parent); - this.animator = animator; - this.activeEditor = activeEditor; - this.f = f; - } - - @Override - public void initGuage() { - this.setExecuteTime(6); - this.setMayCancel(true); - this.setProcessMessage("Starting Visualization ..."); - this.setShellTitle("Starting Visualization"); - } - - @Override - protected String process(int i) { - - switch (i) { - case 1: - try { - createVisualizationRoot(); - } catch (CoreException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } catch (IOException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } catch (ParserConfigurationException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } catch (SAXException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - return "Starting ProB Animator"; - case 2: - startProbAnimator(); - return "Setup Constants"; - case 3: - try { - setupOperation("SETUP_CONTEXT"); - } catch (InterruptedException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - return "Create Visualization"; - case 4: - Display.getDefault().asyncExec(new Runnable() { - public void run() { - createShell(); - } - }); - return "Initialize machine"; - case 5: - try { - setupOperation("INITIALISATION"); - } catch (InterruptedException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - return "Starting Operation Scheduler"; - case 6: - startOperationScheduler(); - return "Starting Visualization"; - } - - return "Starting BMotion Studio Visualization"; - - } - - private void startOperationScheduler() { - visualization.startOperationScheduler(); - } - - private void createVisualizationRoot() throws CoreException, IOException, - ParserConfigurationException, SAXException { - XStream xstream = new XStream(new DomDriver()) { - @Override - protected MapperWrapper wrapMapper(MapperWrapper next) { - return new MapperWrapper(next) { - @Override - public boolean shouldSerializeMember( - @SuppressWarnings("rawtypes") Class definedIn, - String fieldName) { - if (definedIn == Object.class) { - return false; - } - return super - .shouldSerializeMember(definedIn, fieldName); - } - }; - } - }; - BMotionEditorPlugin.setAliases(xstream); - visualization = (Visualization) xstream.fromXML(f.getContents()); - visualization.setProjectFile(f); - } - - @Override - protected void cleanUp() { - if (animation != null) - animation.unregister(); - } - - private void startProbAnimator() { - animation = new Animation(animator, visualization); - ILanguageService langService = getGenericLoadMachine(visualization - .getLanguage()); - if (langService != null) { - try { - langService.startProBAnimator(visualization); - } catch (ProBException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - } else { - openErrorDialog("Unknown formal language: " - + visualization.getLanguage()); - setClose(true); - } - } - - private void setupOperation(String opName) throws InterruptedException { - - final List<Operation> ops = animation.getState().getEnabledOperations(); - - if (ops.size() > 1) { - - Display.getDefault().asyncExec(new Runnable() { - public void run() { - dialog = new SelectOperationDialog(getShell(), ops); - confirm = dialog.open(); - } - }); - - while (true) { - try { - Thread.sleep(500); - } catch (InterruptedException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - - if (confirm == Window.OK) { - Operation op = dialog.getSelectedOperation(); - if (op != null) - try { - ExecuteOperationCommand.executeOperation(animator, - op); - } catch (ProBException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - confirm = -1; - break; - } else if (confirm == Window.CANCEL) { - setClose(true); - confirm = -1; - break; - } - - } - - } else { - Operation op = animation.getCurrentStateOperation(opName); - if (op != null) - try { - ExecuteOperationCommand.executeOperation(animator, op); - } catch (ProBException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - } - - visualization.setIsRunning(true); - - } - - private void createShell() { - activeEditor.createRunPage(visualization, animation); - } - - private ILanguageService getGenericLoadMachine(String language) { - IExtensionRegistry registry = Platform.getExtensionRegistry(); - IExtensionPoint extensionPoint = registry - .getExtensionPoint("de.bmotionstudio.gef.editor.language"); - ILanguageService langService = null; - - // Get GenericLoadMachine command for language - for (IExtension extension : extensionPoint.getExtensions()) { - for (IConfigurationElement configurationElement : extension - .getConfigurationElements()) { - - if ("language".equals(configurationElement.getName())) { - - String languageEx = configurationElement.getAttribute("id"); - if (language.toLowerCase(Locale.ENGLISH).equals( - languageEx.toLowerCase(Locale.ENGLISH))) { - - try { - langService = (ILanguageService) configurationElement - .createExecutableExtension("service"); - } catch (final CoreException e) { - openErrorDialog(e.getMessage()); - setClose(true); - } - - } - - } - - } - } - return langService; - } - - public void kill() { - // if (shell != null) - // if (shell.getShell() != null) - // shell.getShell().dispose(); - } - - public void openErrorDialog(final String msg) { - Display.getDefault().asyncExec(new Runnable() { - public void run() { - ErrorDialog.openError(getParent(), "Error", - "Error creating visualization", new Status( - IStatus.ERROR, BMotionEditorPlugin.PLUGIN_ID, - msg)); - } - }); - } - +/** + * (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.bmotionstudio.gef.editor.internal; + +import java.io.IOException; +import java.util.List; +import java.util.Locale; + +import javax.xml.parsers.ParserConfigurationException; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.IExtension; +import org.eclipse.core.runtime.IExtensionPoint; +import org.eclipse.core.runtime.IExtensionRegistry; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Platform; +import org.eclipse.core.runtime.Status; +import org.eclipse.jface.dialogs.ErrorDialog; +import org.eclipse.jface.window.Window; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; +import org.xml.sax.SAXException; + +import com.thoughtworks.xstream.XStream; +import com.thoughtworks.xstream.io.xml.DomDriver; +import com.thoughtworks.xstream.mapper.MapperWrapper; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.BMotionStudioEditor; +import de.bmotionstudio.gef.editor.ILanguageService; +import de.bmotionstudio.gef.editor.model.Visualization; +import de.prob.core.Animator; +import de.prob.core.command.ExecuteOperationCommand; +import de.prob.core.domainobjects.Operation; +import de.prob.exceptions.ProBException; + +public class VisualizationProgressBar extends ProgressBarDialog { + + private Animator animator; + private IFile f; + private Visualization visualization; + private Animation animation; + private int confirm = -1; + private SelectOperationDialog dialog; + private BMotionStudioEditor activeEditor; + + public VisualizationProgressBar(Shell parent, Animator animator, + BMotionStudioEditor activeEditor, IFile f) { + super(parent); + this.animator = animator; + this.activeEditor = activeEditor; + this.f = f; + } + + @Override + public void initGuage() { + this.setExecuteTime(6); + this.setMayCancel(true); + this.setProcessMessage("Starting Visualization ..."); + this.setShellTitle("Starting Visualization"); + } + + @Override + protected String process(int i) { + + switch (i) { + case 1: + try { + createVisualizationRoot(); + } catch (CoreException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } catch (IOException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } catch (ParserConfigurationException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } catch (SAXException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + return "Starting ProB Animator"; + case 2: + startProbAnimator(); + return "Setup Constants"; + case 3: + try { + setupOperation("SETUP_CONTEXT"); + } catch (InterruptedException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + return "Create Visualization"; + case 4: + Display.getDefault().asyncExec(new Runnable() { + public void run() { + createShell(); + } + }); + return "Initialize machine"; + case 5: + try { + setupOperation("INITIALISATION"); + } catch (InterruptedException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + return "Starting Operation Scheduler"; + case 6: + startOperationScheduler(); + return "Starting Visualization"; + } + + return "Starting BMotion Studio Visualization"; + + } + + private void startOperationScheduler() { + visualization.startOperationScheduler(); + } + + private void createVisualizationRoot() throws CoreException, IOException, + ParserConfigurationException, SAXException { + XStream xstream = new XStream(new DomDriver()) { + @Override + protected MapperWrapper wrapMapper(MapperWrapper next) { + return new MapperWrapper(next) { + @Override + public boolean shouldSerializeMember( + @SuppressWarnings("rawtypes") Class definedIn, + String fieldName) { + if (definedIn == Object.class) { + return false; + } + return super + .shouldSerializeMember(definedIn, fieldName); + } + }; + } + }; + BMotionEditorPlugin.setAliases(xstream); + visualization = (Visualization) xstream.fromXML(f.getContents()); + visualization.setProjectFile(f); + } + + @Override + protected void cleanUp() { + if (animation != null) + animation.unregister(); + } + + private void startProbAnimator() { + animation = new Animation(animator, visualization); + ILanguageService langService = getGenericLoadMachine(visualization + .getLanguage()); + if (langService != null) { + try { + langService.startProBAnimator(visualization); + } catch (ProBException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + } else { + openErrorDialog("Unknown formal language: " + + visualization.getLanguage()); + setClose(true); + } + } + + private void setupOperation(String opName) throws InterruptedException { + + final List<Operation> ops = animation.getState().getEnabledOperations(); + + if (ops.size() > 1) { + + Display.getDefault().asyncExec(new Runnable() { + public void run() { + dialog = new SelectOperationDialog(getShell(), ops); + confirm = dialog.open(); + } + }); + + while (true) { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + + if (confirm == Window.OK) { + Operation op = dialog.getSelectedOperation(); + if (op != null) + try { + ExecuteOperationCommand.executeOperation(animator, + op); + } catch (ProBException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + confirm = -1; + break; + } else if (confirm == Window.CANCEL) { + setClose(true); + confirm = -1; + break; + } + + } + + } else { + Operation op = animation.getCurrentStateOperation(opName); + if (op != null) + try { + ExecuteOperationCommand.executeOperation(animator, op); + } catch (ProBException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + } + + visualization.setIsRunning(true); + + } + + private void createShell() { + activeEditor.createRunPage(visualization, animation); + } + + private ILanguageService getGenericLoadMachine(String language) { + IExtensionRegistry registry = Platform.getExtensionRegistry(); + IExtensionPoint extensionPoint = registry + .getExtensionPoint("de.bmotionstudio.gef.editor.language"); + ILanguageService langService = null; + + // Get GenericLoadMachine command for language + for (IExtension extension : extensionPoint.getExtensions()) { + for (IConfigurationElement configurationElement : extension + .getConfigurationElements()) { + + if ("language".equals(configurationElement.getName())) { + + String languageEx = configurationElement.getAttribute("id"); + if (language.toLowerCase(Locale.ENGLISH).equals( + languageEx.toLowerCase(Locale.ENGLISH))) { + + try { + langService = (ILanguageService) configurationElement + .createExecutableExtension("service"); + } catch (final CoreException e) { + openErrorDialog(e.getMessage()); + setClose(true); + } + + } + + } + + } + } + return langService; + } + + public void kill() { + // if (shell != null) + // if (shell.getShell() != null) + // shell.getShell().dispose(); + } + + public void openErrorDialog(final String msg) { + Display.getDefault().asyncExec(new Runnable() { + public void run() { + ErrorDialog.openError(getParent(), "Error", + "Error creating visualization", new Status( + IStatus.ERROR, BMotionEditorPlugin.PLUGIN_ID, + msg)); + } + }); + } + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryObject.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryObject.java index 25ae33b0adc6efd18ccd05eb6e2c260401c7b590..d84a1cf87b4cbf5ede40061f826d4574808fc3b5 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryObject.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryObject.java @@ -1,54 +1,54 @@ -/** - * (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.bmotionstudio.gef.editor.library; - -import org.eclipse.swt.graphics.Image; - -public class LibraryObject { - - private String name; - private String type; - private Image typeImage; - - public LibraryObject(String name, String type, Image typeImage) { - this.name = name; - this.type = type; - this.typeImage = typeImage; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public String getType() { - return type; - } - - public void setType(String type) { - this.type = type; - } - - public void setImage(Image image) { - this.typeImage = image; - } - - public Image getImage() { - return typeImage; - } - - public void delete(LibraryPage page) { - } - - public Image getPreview(LibraryPage page) { - return null; - } - -} +/** + * (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.bmotionstudio.gef.editor.library; + +import org.eclipse.swt.graphics.Image; + +public class LibraryObject { + + private String name; + private String type; + private Image typeImage; + + public LibraryObject(String name, String type, Image typeImage) { + this.name = name; + this.type = type; + this.typeImage = typeImage; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public void setImage(Image image) { + this.typeImage = image; + } + + public Image getImage() { + return typeImage; + } + + public void delete(LibraryPage page) { + } + + public Image getPreview(LibraryPage page) { + return null; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryView.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryView.java index 08240a63b7a45fd3e70872f75bd61fbefeb93742..962029267cbb388066a6e8dad0d927d75f098eb8 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryView.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/library/LibraryView.java @@ -1,76 +1,76 @@ -/** - * (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.bmotionstudio.gef.editor.library; - -import org.eclipse.ui.IEditorPart; -import org.eclipse.ui.IWorkbenchPage; -import org.eclipse.ui.IWorkbenchPart; -import org.eclipse.ui.part.IPage; -import org.eclipse.ui.part.MessagePage; -import org.eclipse.ui.part.PageBook; -import org.eclipse.ui.part.PageBookView; - -import de.bmotionstudio.gef.editor.BMotionStudioEditor; - -public class LibraryView extends PageBookView { - - public static String ID = "de.bmotionstudio.gef.editor.LibraryView"; - - private String defaultText = "A library is not available."; - - private LibraryPage page; - - public LibraryView() { - super(); - } - - @Override - protected IPage createDefaultPage(PageBook book) { - MessagePage page = new MessagePage(); - initPage(page); - page.createControl(book); - page.setMessage(defaultText); - return page; - } - - @Override - protected PageRec doCreatePage(IWorkbenchPart part) { - if (part instanceof BMotionStudioEditor) { - page = new LibraryPage((BMotionStudioEditor) part); - initPage(page); - page.createControl(getPageBook()); - return new PageRec(part, page); - } - return null; - } - - @Override - protected void doDestroyPage(IWorkbenchPart part, PageRec rec) { - LibraryPage page = (LibraryPage) rec.page; - page.dispose(); - rec.dispose(); - } - - @Override - protected IWorkbenchPart getBootstrapPart() { - IWorkbenchPage page = getSite().getPage(); - if (page != null) { - return page.getActiveEditor(); - } - return null; - } - - public void partBroughtToTop(IWorkbenchPart part) { - partActivated(part); - } - - @Override - protected boolean isImportant(IWorkbenchPart part) { - return (part instanceof IEditorPart); - } - +/** + * (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.bmotionstudio.gef.editor.library; + +import org.eclipse.ui.IEditorPart; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.IWorkbenchPart; +import org.eclipse.ui.part.IPage; +import org.eclipse.ui.part.MessagePage; +import org.eclipse.ui.part.PageBook; +import org.eclipse.ui.part.PageBookView; + +import de.bmotionstudio.gef.editor.BMotionStudioEditor; + +public class LibraryView extends PageBookView { + + public static String ID = "de.bmotionstudio.gef.editor.LibraryView"; + + private String defaultText = "A library is not available."; + + private LibraryPage page; + + public LibraryView() { + super(); + } + + @Override + protected IPage createDefaultPage(PageBook book) { + MessagePage page = new MessagePage(); + initPage(page); + page.createControl(book); + page.setMessage(defaultText); + return page; + } + + @Override + protected PageRec doCreatePage(IWorkbenchPart part) { + if (part instanceof BMotionStudioEditor) { + page = new LibraryPage((BMotionStudioEditor) part); + initPage(page); + page.createControl(getPageBook()); + return new PageRec(part, page); + } + return null; + } + + @Override + protected void doDestroyPage(IWorkbenchPart part, PageRec rec) { + LibraryPage page = (LibraryPage) rec.page; + page.dispose(); + rec.dispose(); + } + + @Override + protected IWorkbenchPart getBootstrapPart() { + IWorkbenchPage page = getSite().getPage(); + if (page != null) { + return page.getActiveEditor(); + } + return null; + } + + public void partBroughtToTop(IWorkbenchPart part) { + partActivated(part); + } + + @Override + protected boolean isImportant(IWorkbenchPart part) { + return (part instanceof IEditorPart); + } + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/model/BControl.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/model/BControl.java index 37df8512aa391cdd03e502b9091e0624e71c6786..7ea8dce56ee5f79bb1bf94ad899090bdf0c5a86c 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/model/BControl.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/model/BControl.java @@ -1,760 +1,760 @@ -/** - * (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.bmotionstudio.gef.editor.model; - -import java.beans.PropertyChangeListener; -import java.beans.PropertyChangeSupport; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.UUID; - -import org.eclipse.core.runtime.CoreException; -import org.eclipse.core.runtime.IAdaptable; -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.draw2d.geometry.Dimension; -import org.eclipse.draw2d.geometry.Point; -import org.eclipse.draw2d.geometry.Rectangle; -import org.eclipse.ui.views.properties.IPropertySource; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.IBControlService; -import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; -import de.bmotionstudio.gef.editor.attribute.BAttributeCoordinates; -import de.bmotionstudio.gef.editor.attribute.BAttributeCustom; -import de.bmotionstudio.gef.editor.attribute.BAttributeHeight; -import de.bmotionstudio.gef.editor.attribute.BAttributeID; -import de.bmotionstudio.gef.editor.attribute.BAttributeSize; -import de.bmotionstudio.gef.editor.attribute.BAttributeVisible; -import de.bmotionstudio.gef.editor.attribute.BAttributeWidth; -import de.bmotionstudio.gef.editor.attribute.BAttributeX; -import de.bmotionstudio.gef.editor.attribute.BAttributeY; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.internal.BControlPropertySource; -import de.bmotionstudio.gef.editor.observer.IObserverListener; -import de.bmotionstudio.gef.editor.observer.Observer; -import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; - -/** - * - * A Control is a graphical representation of some aspects of the model. - * Typically we use labels, images or buttons to represent informations. For - * instance, if we model a system that has a temperature and a threshold - * temperature that triggers a cool down, we might simply use two labels - * displaying both values, or maybe we can incorporate both information into a - * gauge display. It is also possible to define new controls for domain specific - * visualizations. - * - * @author Lukas Ladenberger - * - */ -public abstract class BControl implements IAdaptable, Cloneable { - - /** The type of the control (e.g. label, button ...) */ - protected String type; - - private transient Rectangle layout = null; - - private transient Point location = null; - - private BControlList children; - - private Map<String, Observer> observers; - - private Map<String, SchedulerEvent> events; - - private Map<String, AbstractAttribute> attributes; - - /** - * Since the parent is set via the method readResolve(), we mark the - * variable as transient - */ - private transient BControl parent; - - private transient Visualization visualization; - - private transient PropertyChangeSupport listeners; - - private transient ArrayList<IObserverListener> observerListener; - - private BMotionGuide verticalGuide, horizontalGuide; - - /** List of outgoing Connections. */ - private List<BConnection> sourceConnections; - /** List of incoming Connections. */ - private List<BConnection> targetConnections; - - public static final transient String PROPERTY_LAYOUT = "NodeLayout"; - public static final transient String PROPERTY_LOCATION = "NodeLocation"; - public static final transient String PROPERTY_ADD = "NodeAddChild"; - public static final transient String PROPERTY_REMOVE = "NodeRemoveChild"; - public static final transient String PROPERTY_RENAME = "NodeRename"; - /** Property ID to use when the list of outgoing connections is modified. */ - public static final String SOURCE_CONNECTIONS_PROP = "BMS.SourceConn"; - /** Property ID to use when the list of incoming connections is modified. */ - public static final String TARGET_CONNECTIONS_PROP = "BMS.TargetConn"; - - public BControl(Visualization visualization) { - this.visualization = visualization; - this.children = new BControlList(); - this.observers = new HashMap<String, Observer>(); - this.events = new HashMap<String, SchedulerEvent>(); - this.attributes = new HashMap<String, AbstractAttribute>(); - this.listeners = new PropertyChangeSupport(this); - this.observerListener = new ArrayList<IObserverListener>(); - this.sourceConnections = new ArrayList<BConnection>(); - this.targetConnections = new ArrayList<BConnection>(); - init(); - } - - protected Object readResolve() { - // Populate parent - for (BControl child : getChildrenArray()) - child.setParent(this); - return this; - } - - /** - * Remove an incoming or outgoing connection from this shape. - * - * @param conn - * a non-null connection instance - * @throws IllegalArgumentException - * if the parameter is null - */ - public void removeConnection(BConnection conn) { - if (conn == null) { - throw new IllegalArgumentException(); - } - if (conn.getSource() == this) { - getSourceConnections().remove(conn); - getListeners().firePropertyChange(SOURCE_CONNECTIONS_PROP, null, - conn); - } else if (conn.getTarget() == this) { - getTargetConnections().remove(conn); - getListeners().firePropertyChange(TARGET_CONNECTIONS_PROP, null, - conn); - } - } - - /** - * Add an incoming or outgoing connection to this shape. - * - * @param conn - * a non-null connection instance - * @throws IllegalArgumentException - * if the connection is null or has not distinct endpoints - */ - public void addConnection(BConnection conn) { - if (conn == null || conn.getSource() == conn.getTarget()) { - throw new IllegalArgumentException(); - } - conn.setVisualization(getVisualization()); - if (conn.getSource() == this) { - getSourceConnections().add(conn); - getListeners().firePropertyChange(SOURCE_CONNECTIONS_PROP, null, - conn); - } else if (conn.getTarget() == this) { - getTargetConnections().add(conn); - getListeners().firePropertyChange(TARGET_CONNECTIONS_PROP, null, - conn); - } - } - - private void init() { - - // Init ID - String ID; - if (this instanceof Visualization) - ID = "visualization"; - else if (visualization == null) - ID = UUID.randomUUID().toString(); - else - ID = (visualization.getMaxIDString(type)); - initAttribute(new BAttributeID(ID), AbstractAttribute.ROOT); - - // Init location and dimension attributes - BAttributeCoordinates coordinatesAtr = new BAttributeCoordinates(null); - initAttribute(coordinatesAtr, AbstractAttribute.ROOT); - initAttribute(new BAttributeX(100), coordinatesAtr); - initAttribute(new BAttributeY(100), coordinatesAtr); - - BAttributeSize sizeAtr = new BAttributeSize(null); - initAttribute(sizeAtr, AbstractAttribute.ROOT); - initAttribute(new BAttributeWidth(100), sizeAtr); - initAttribute(new BAttributeHeight(100), sizeAtr); - - // Init visible and this attribute - initAttribute(new BAttributeVisible(true), AbstractAttribute.ROOT); - initAttribute(new BAttributeCustom(""), AbstractAttribute.ROOT); - - // Init custom control attributes - initAttributes(); - - } - - protected abstract void initAttributes(); - - public String getID() { - return getAttributeValue(AttributeConstants.ATTRIBUTE_ID).toString(); - } - - public AbstractAttribute getAttribute(String attributeID) { - return getAttributes().get(attributeID); - } - - public Object getAttributeValue(String attributeID) { - - AbstractAttribute atr = attributes.get(attributeID); - - if (atr != null) { - return atr.getValue(); - } else { - // TODO: handle error/exception (no such attribute) - return null; - } - - } - - public boolean setAttributeValue(String attributeID, Object value) { - return setAttributeValue(attributeID, value, true); - } - - public boolean setAttributeValue(String attributeID, Object value, - Boolean firePropertyChange) { - - AbstractAttribute atr = attributes.get(attributeID); - - if (atr == null) { - return false; - // TODO: Throw some error!?! - } - - atr.setControl(this); - - if ((atr.getValue() != null && atr.getValue().equals(value)) - || !atr.isEditable()) - return true; - - atr.setValue(value, firePropertyChange); - - return true; - - } - - public void restoreDefaultValue(String attributeID) { - AbstractAttribute atr = attributes.get(attributeID); - if (atr != null) { - atr.restoreValue(); - Object oldVal = atr.getValue(); - Object initValue = atr.getInitValue(); - getListeners().firePropertyChange(attributeID, oldVal, initValue); - } - } - - public boolean hasAttribute(String attributeID) { - return attributes.containsKey(attributeID); - } - - public void setLayout(Rectangle newLayout) { - Rectangle oldLayout = getLayout(); - layout = newLayout; - setAttributeValue(AttributeConstants.ATTRIBUTE_X, newLayout.x, false); - setAttributeValue(AttributeConstants.ATTRIBUTE_Y, newLayout.y, false); - setAttributeValue(AttributeConstants.ATTRIBUTE_WIDTH, newLayout.width, - false); - setAttributeValue(AttributeConstants.ATTRIBUTE_HEIGHT, - newLayout.height, false); - getListeners() - .firePropertyChange(PROPERTY_LAYOUT, oldLayout, newLayout); - } - - public Rectangle getLayout() { - int width = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_WIDTH).toString()); - int height = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_HEIGHT).toString()); - int x = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_X).toString()); - int y = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_Y).toString()); - if (layout == null) { - layout = new Rectangle(x, y, width, height); - } else { - layout.x = x; - layout.y = y; - layout.width = width; - layout.height = height; - } - return layout; - } - - public void setLocation(Point newLocation) { - Point oldLocation = getLocation(); - location = newLocation; - setAttributeValue(AttributeConstants.ATTRIBUTE_X, newLocation.x, false); - setAttributeValue(AttributeConstants.ATTRIBUTE_Y, newLocation.y, false); - getListeners().firePropertyChange(PROPERTY_LOCATION, oldLocation, - newLocation); - } - - public Point getLocation() { - int x = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_X).toString()); - int y = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_Y).toString()); - if (location == null) { - location = new Point(x, y); - } else { - location.x = x; - location.y = y; - } - return location; - } - - public Dimension getDimension() { - int width = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_WIDTH).toString()); - int height = Integer.valueOf(getAttributeValue( - AttributeConstants.ATTRIBUTE_HEIGHT).toString()); - return new Dimension(width, height); - } - - public void addChild(BControl child) { - addChild(child, -1); - } - - public void addChild(BControl child, int index) { - child.setParent(this); - if (index >= 0) { - children.add(index, child); - } else { - children.add(child); - } - getListeners().firePropertyChange(PROPERTY_ADD, index, child); - } - - public boolean removeChild(BControl child) { - boolean b = children.remove(child); - if (b) - getListeners().firePropertyChange(PROPERTY_REMOVE, child, null); - return b; - } - - public List<BControl> getChildrenArray() { - if (children == null) - children = new BControlList(); - return children; - } - - public void setChildrenArray(BControlList children) { - this.children = children; - } - - public boolean hasChildren() { - return children.size() > 0; - } - - public BControl getChild(String ID) { - for (BControl bcontrol : children) { - String bcontrolID = bcontrol.getAttributeValue( - AttributeConstants.ATTRIBUTE_ID).toString(); - if (bcontrolID != null) { - if (bcontrolID.equals(ID)) - return bcontrol; - } - } - return null; - } - - public Map<String, Observer> getObservers() { - if (observers == null) - observers = new HashMap<String, Observer>(); - return observers; - } - - public Observer getObserver(String observerID) { - return this.observers.get(observerID); - } - - public Boolean hasObserver(String ID) { - if (getObservers().containsKey(ID)) - return true; - return false; - } - - public void addObserver(Observer observer) { - observers.put(observer.getID(), (Observer) observer); - for (IObserverListener listener : getObserverListener()) { - listener.addedObserver(this, observer); - } - } - - public void removeObserver(String observerID) { - if (hasObserver(observerID)) - observers.get(observerID).beforeDelete(this); - observers.remove(observerID); - for (IObserverListener listener : getObserverListener()) { - listener.removedObserver(this); - } - } - - public Map<String, SchedulerEvent> getEvents() { - if (events == null) - events = new HashMap<String, SchedulerEvent>(); - return events; - } - - public SchedulerEvent getEvent(String ID) { - return events.get(ID); - } - - public Boolean hasEvent(String ID) { - if (getEvents().containsKey(ID)) - return true; - return false; - } - - public void addEvent(String eventID, SchedulerEvent schedulerEvent) { - events.put(eventID, schedulerEvent); - } - - public void removeEvent(String eventID) { - if (hasEvent(eventID)) - events.get(eventID).beforeDelete(this); - events.remove(eventID); - } - - public Map<String, AbstractAttribute> getAttributes() { - return attributes; - } - - public void setAttributes(Map<String, AbstractAttribute> attributes) { - this.attributes = attributes; - } - - public void setParent(BControl parent) { - this.parent = parent; - } - - public BControl getParent() { - return this.parent; - } - - public void addPropertyChangeListener(PropertyChangeListener listener) { - getListeners().addPropertyChangeListener(listener); - } - - public PropertyChangeSupport getListeners() { - if (listeners == null) - listeners = new PropertyChangeSupport(this); - return listeners; - } - - public void removePropertyChangeListener(PropertyChangeListener listener) { - getListeners().removePropertyChangeListener(listener); - } - - public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) { - if (adapter == IPropertySource.class) { - return new BControlPropertySource(this); - } - return null; - } - - public boolean contains(BControl child) { - return children.contains(child); - } - - public String getDefaultValue(String attributeID) { - - IConfigurationElement configurationElement = BMotionEditorPlugin - .getControlExtension(getType()); - - if (configurationElement != null) { - - for (final IConfigurationElement configBAttributes : configurationElement - .getChildren("attributes")) { - - for (final IConfigurationElement configBAttribute : configBAttributes - .getChildren("attribute-string")) { - - String aID = configBAttribute.getAttribute("id"); - - if (aID.equals(attributeID)) { - String attributeDefaultValue = configBAttribute - .getAttribute("default-value"); - - return attributeDefaultValue; - } - - } - - } - - } - - return null; - - } - - public Boolean isAttributeEditable(String attributeID) { - - IConfigurationElement configurationElement = BMotionEditorPlugin - .getControlExtension(getType()); - - if (configurationElement != null) { - - for (final IConfigurationElement configBAttributes : configurationElement - .getChildren("attributes")) { - - for (final IConfigurationElement configBAttribute : configBAttributes - .getChildren("attribute-string")) { - - String aID = configBAttribute.getAttribute("id"); - - if (aID.equals(attributeID)) { - String val = configBAttribute.getAttribute("editable"); - return Boolean.valueOf(val); - } - - } - - } - - } - - return false; - - } - - public Visualization getVisualization() { - return visualization; - } - - public void setVisualization(Visualization visualization) { - this.visualization = visualization; - } - - protected void populateVisualization(Visualization visualization) { - // Populate visualization node - setVisualization(visualization); - for (BControl child : getChildrenArray()) - child.populateVisualization(visualization); - for (BConnection con : getTargetConnections()) - con.populateVisualization(visualization); - for (BConnection con : getSourceConnections()) - con.populateVisualization(visualization); - } - - @Override - public BControl clone() throws CloneNotSupportedException { - - BControl clonedControl = (BControl) super.clone(); - - IConfigurationElement configElement = BMotionEditorPlugin - .getControlServices().get(getType()); - if (configElement != null) { - - try { - - IBControlService service = (IBControlService) configElement - .createExecutableExtension("service"); - clonedControl = service.createControl(visualization); - - clonedControl.setParent(getParent()); - - String newID = clonedControl.getID(); - - Map<String, AbstractAttribute> newProperties = new HashMap<String, AbstractAttribute>(); - for (Entry<String, AbstractAttribute> e : getAttributes() - .entrySet()) { - AbstractAttribute idAtr = e.getValue().clone(); - newProperties.put(e.getKey(), idAtr); - } - - clonedControl.setAttributes(newProperties); - clonedControl.setAttributeValue( - AttributeConstants.ATTRIBUTE_ID, newID); - - Iterator<BControl> it = getChildrenArray().iterator(); - while (it.hasNext()) { - clonedControl.addChild(((BControl) it.next()).clone()); - } - - for (Observer observer : observers.values()) { - clonedControl.addObserver(observer.clone()); - } - - for (Map.Entry<String, SchedulerEvent> e : events.entrySet()) { - clonedControl.addEvent(e.getKey(), e.getValue().clone()); - } - - } catch (CoreException e) { - e.printStackTrace(); - } - - } - - return clonedControl; - - } - - public void checkObserver(final Animation animation) { - - // Check all Observers - for (Observer observer : getObservers().values()) { - observer.check(animation, BControl.this); - } - - // TODO: Currently connection observer are checked twice (source + - // target) => change this, so that observer are checked only on time per - // state!!! - for (BConnection con : getSourceConnections()) { - con.checkObserver(animation); - } - for (BConnection con : getTargetConnections()) { - con.checkObserver(animation); - } - - // Check Observers of children - if (getChildrenArray().size() > 0) { - for (BControl bcontrol : getChildrenArray()) { - bcontrol.checkObserver(animation); - } - } - - } - - public void afterCheckObserver(Animation animation) { - // Check all Observers - for (Observer observer : getObservers().values()) { - observer.afterCheck(animation, this); - } - // Check Observers of children - if (getChildrenArray().size() > 0) { - for (BControl bcontrol : getChildrenArray()) { - bcontrol.afterCheckObserver(animation); - } - } - } - - public void executeEvent(String eventID) { - if (hasAttribute(AttributeConstants.ATTRIBUTE_ENABLED)) { - if (!(Boolean) getAttributeValue(AttributeConstants.ATTRIBUTE_ENABLED)) - return; - } - SchedulerEvent e = getEvents().get(eventID); - if (e != null) - e.execute(getVisualization().getAnimation(), this); - } - - public void setVerticalGuide(BMotionGuide verticalGuide) { - this.verticalGuide = verticalGuide; - } - - public BMotionGuide getVerticalGuide() { - return verticalGuide; - } - - public void setHorizontalGuide(BMotionGuide horizontalGuide) { - this.horizontalGuide = horizontalGuide; - } - - public BMotionGuide getHorizontalGuide() { - return horizontalGuide; - } - - /** - * @return the observerListener - */ - public ArrayList<IObserverListener> getObserverListener() { - if (observerListener == null) - observerListener = new ArrayList<IObserverListener>(); - return observerListener; - } - - public void addObserverListener(IObserverListener listener) { - getObserverListener().add(listener); - } - - public void removeObserverListener(IObserverListener listener) { - getObserverListener().remove(listener); - } - - /** - * Return a List of outgoing Connections. - */ - public List<BConnection> getSourceConnections() { - if (this.sourceConnections == null) - this.sourceConnections = new ArrayList<BConnection>(); - return this.sourceConnections; - } - - public void setSourceConnections(List<BConnection> connections) { - this.sourceConnections = connections; - } - - public void setTargetConnections(List<BConnection> connections) { - this.targetConnections = connections; - } - - /** - * Return a List of incoming Connections. - */ - public List<BConnection> getTargetConnections() { - if (this.targetConnections == null) - this.targetConnections = new ArrayList<BConnection>(); - return this.targetConnections; - } - - public boolean hasConnections() { - return !getTargetConnections().isEmpty() - || !getSourceConnections().isEmpty(); - } - - public boolean showInOutlineView() { - return true; - } - - public void setObserverMap(Map<String, Observer> observerMap) { - observers = observerMap; - } - - public void setEventMap(Map<String, SchedulerEvent> eventMap) { - events = eventMap; - } - - public abstract String getType(); - - protected void initAttribute(AbstractAttribute atr) { - getAttributes().put(atr.getID(), atr); - } - - protected void initAttribute(AbstractAttribute atr, AbstractAttribute group) { - initAttribute(atr, group.getClass().getName()); - } - - protected void initAttribute(AbstractAttribute atr, String group) { - atr.setGroup(group); - initAttribute(atr); - } - - public boolean canHaveChildren() { - return false; - } - - public String getValueOfData() { - return getAttributeValue(AttributeConstants.ATTRIBUTE_CUSTOM) - .toString(); - } - -} +/** + * (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.bmotionstudio.gef.editor.model; + +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.UUID; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IAdaptable; +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.draw2d.geometry.Dimension; +import org.eclipse.draw2d.geometry.Point; +import org.eclipse.draw2d.geometry.Rectangle; +import org.eclipse.ui.views.properties.IPropertySource; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.IBControlService; +import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; +import de.bmotionstudio.gef.editor.attribute.BAttributeCoordinates; +import de.bmotionstudio.gef.editor.attribute.BAttributeCustom; +import de.bmotionstudio.gef.editor.attribute.BAttributeHeight; +import de.bmotionstudio.gef.editor.attribute.BAttributeID; +import de.bmotionstudio.gef.editor.attribute.BAttributeSize; +import de.bmotionstudio.gef.editor.attribute.BAttributeVisible; +import de.bmotionstudio.gef.editor.attribute.BAttributeWidth; +import de.bmotionstudio.gef.editor.attribute.BAttributeX; +import de.bmotionstudio.gef.editor.attribute.BAttributeY; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.internal.BControlPropertySource; +import de.bmotionstudio.gef.editor.observer.IObserverListener; +import de.bmotionstudio.gef.editor.observer.Observer; +import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; + +/** + * + * A Control is a graphical representation of some aspects of the model. + * Typically we use labels, images or buttons to represent informations. For + * instance, if we model a system that has a temperature and a threshold + * temperature that triggers a cool down, we might simply use two labels + * displaying both values, or maybe we can incorporate both information into a + * gauge display. It is also possible to define new controls for domain specific + * visualizations. + * + * @author Lukas Ladenberger + * + */ +public abstract class BControl implements IAdaptable, Cloneable { + + /** The type of the control (e.g. label, button ...) */ + protected String type; + + private transient Rectangle layout = null; + + private transient Point location = null; + + private BControlList children; + + private Map<String, Observer> observers; + + private Map<String, SchedulerEvent> events; + + private Map<String, AbstractAttribute> attributes; + + /** + * Since the parent is set via the method readResolve(), we mark the + * variable as transient + */ + private transient BControl parent; + + private transient Visualization visualization; + + private transient PropertyChangeSupport listeners; + + private transient ArrayList<IObserverListener> observerListener; + + private BMotionGuide verticalGuide, horizontalGuide; + + /** List of outgoing Connections. */ + private List<BConnection> sourceConnections; + /** List of incoming Connections. */ + private List<BConnection> targetConnections; + + public static final transient String PROPERTY_LAYOUT = "NodeLayout"; + public static final transient String PROPERTY_LOCATION = "NodeLocation"; + public static final transient String PROPERTY_ADD = "NodeAddChild"; + public static final transient String PROPERTY_REMOVE = "NodeRemoveChild"; + public static final transient String PROPERTY_RENAME = "NodeRename"; + /** Property ID to use when the list of outgoing connections is modified. */ + public static final String SOURCE_CONNECTIONS_PROP = "BMS.SourceConn"; + /** Property ID to use when the list of incoming connections is modified. */ + public static final String TARGET_CONNECTIONS_PROP = "BMS.TargetConn"; + + public BControl(Visualization visualization) { + this.visualization = visualization; + this.children = new BControlList(); + this.observers = new HashMap<String, Observer>(); + this.events = new HashMap<String, SchedulerEvent>(); + this.attributes = new HashMap<String, AbstractAttribute>(); + this.listeners = new PropertyChangeSupport(this); + this.observerListener = new ArrayList<IObserverListener>(); + this.sourceConnections = new ArrayList<BConnection>(); + this.targetConnections = new ArrayList<BConnection>(); + init(); + } + + protected Object readResolve() { + // Populate parent + for (BControl child : getChildrenArray()) + child.setParent(this); + return this; + } + + /** + * Remove an incoming or outgoing connection from this shape. + * + * @param conn + * a non-null connection instance + * @throws IllegalArgumentException + * if the parameter is null + */ + public void removeConnection(BConnection conn) { + if (conn == null) { + throw new IllegalArgumentException(); + } + if (conn.getSource() == this) { + getSourceConnections().remove(conn); + getListeners().firePropertyChange(SOURCE_CONNECTIONS_PROP, null, + conn); + } else if (conn.getTarget() == this) { + getTargetConnections().remove(conn); + getListeners().firePropertyChange(TARGET_CONNECTIONS_PROP, null, + conn); + } + } + + /** + * Add an incoming or outgoing connection to this shape. + * + * @param conn + * a non-null connection instance + * @throws IllegalArgumentException + * if the connection is null or has not distinct endpoints + */ + public void addConnection(BConnection conn) { + if (conn == null || conn.getSource() == conn.getTarget()) { + throw new IllegalArgumentException(); + } + conn.setVisualization(getVisualization()); + if (conn.getSource() == this) { + getSourceConnections().add(conn); + getListeners().firePropertyChange(SOURCE_CONNECTIONS_PROP, null, + conn); + } else if (conn.getTarget() == this) { + getTargetConnections().add(conn); + getListeners().firePropertyChange(TARGET_CONNECTIONS_PROP, null, + conn); + } + } + + private void init() { + + // Init ID + String ID; + if (this instanceof Visualization) + ID = "visualization"; + else if (visualization == null) + ID = UUID.randomUUID().toString(); + else + ID = (visualization.getMaxIDString(type)); + initAttribute(new BAttributeID(ID), AbstractAttribute.ROOT); + + // Init location and dimension attributes + BAttributeCoordinates coordinatesAtr = new BAttributeCoordinates(null); + initAttribute(coordinatesAtr, AbstractAttribute.ROOT); + initAttribute(new BAttributeX(100), coordinatesAtr); + initAttribute(new BAttributeY(100), coordinatesAtr); + + BAttributeSize sizeAtr = new BAttributeSize(null); + initAttribute(sizeAtr, AbstractAttribute.ROOT); + initAttribute(new BAttributeWidth(100), sizeAtr); + initAttribute(new BAttributeHeight(100), sizeAtr); + + // Init visible and this attribute + initAttribute(new BAttributeVisible(true), AbstractAttribute.ROOT); + initAttribute(new BAttributeCustom(""), AbstractAttribute.ROOT); + + // Init custom control attributes + initAttributes(); + + } + + protected abstract void initAttributes(); + + public String getID() { + return getAttributeValue(AttributeConstants.ATTRIBUTE_ID).toString(); + } + + public AbstractAttribute getAttribute(String attributeID) { + return getAttributes().get(attributeID); + } + + public Object getAttributeValue(String attributeID) { + + AbstractAttribute atr = attributes.get(attributeID); + + if (atr != null) { + return atr.getValue(); + } else { + // TODO: handle error/exception (no such attribute) + return null; + } + + } + + public boolean setAttributeValue(String attributeID, Object value) { + return setAttributeValue(attributeID, value, true); + } + + public boolean setAttributeValue(String attributeID, Object value, + Boolean firePropertyChange) { + + AbstractAttribute atr = attributes.get(attributeID); + + if (atr == null) { + return false; + // TODO: Throw some error!?! + } + + atr.setControl(this); + + if ((atr.getValue() != null && atr.getValue().equals(value)) + || !atr.isEditable()) + return true; + + atr.setValue(value, firePropertyChange); + + return true; + + } + + public void restoreDefaultValue(String attributeID) { + AbstractAttribute atr = attributes.get(attributeID); + if (atr != null) { + atr.restoreValue(); + Object oldVal = atr.getValue(); + Object initValue = atr.getInitValue(); + getListeners().firePropertyChange(attributeID, oldVal, initValue); + } + } + + public boolean hasAttribute(String attributeID) { + return attributes.containsKey(attributeID); + } + + public void setLayout(Rectangle newLayout) { + Rectangle oldLayout = getLayout(); + layout = newLayout; + setAttributeValue(AttributeConstants.ATTRIBUTE_X, newLayout.x, false); + setAttributeValue(AttributeConstants.ATTRIBUTE_Y, newLayout.y, false); + setAttributeValue(AttributeConstants.ATTRIBUTE_WIDTH, newLayout.width, + false); + setAttributeValue(AttributeConstants.ATTRIBUTE_HEIGHT, + newLayout.height, false); + getListeners() + .firePropertyChange(PROPERTY_LAYOUT, oldLayout, newLayout); + } + + public Rectangle getLayout() { + int width = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_WIDTH).toString()); + int height = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_HEIGHT).toString()); + int x = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_X).toString()); + int y = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_Y).toString()); + if (layout == null) { + layout = new Rectangle(x, y, width, height); + } else { + layout.x = x; + layout.y = y; + layout.width = width; + layout.height = height; + } + return layout; + } + + public void setLocation(Point newLocation) { + Point oldLocation = getLocation(); + location = newLocation; + setAttributeValue(AttributeConstants.ATTRIBUTE_X, newLocation.x, false); + setAttributeValue(AttributeConstants.ATTRIBUTE_Y, newLocation.y, false); + getListeners().firePropertyChange(PROPERTY_LOCATION, oldLocation, + newLocation); + } + + public Point getLocation() { + int x = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_X).toString()); + int y = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_Y).toString()); + if (location == null) { + location = new Point(x, y); + } else { + location.x = x; + location.y = y; + } + return location; + } + + public Dimension getDimension() { + int width = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_WIDTH).toString()); + int height = Integer.valueOf(getAttributeValue( + AttributeConstants.ATTRIBUTE_HEIGHT).toString()); + return new Dimension(width, height); + } + + public void addChild(BControl child) { + addChild(child, -1); + } + + public void addChild(BControl child, int index) { + child.setParent(this); + if (index >= 0) { + children.add(index, child); + } else { + children.add(child); + } + getListeners().firePropertyChange(PROPERTY_ADD, index, child); + } + + public boolean removeChild(BControl child) { + boolean b = children.remove(child); + if (b) + getListeners().firePropertyChange(PROPERTY_REMOVE, child, null); + return b; + } + + public List<BControl> getChildrenArray() { + if (children == null) + children = new BControlList(); + return children; + } + + public void setChildrenArray(BControlList children) { + this.children = children; + } + + public boolean hasChildren() { + return children.size() > 0; + } + + public BControl getChild(String ID) { + for (BControl bcontrol : children) { + String bcontrolID = bcontrol.getAttributeValue( + AttributeConstants.ATTRIBUTE_ID).toString(); + if (bcontrolID != null) { + if (bcontrolID.equals(ID)) + return bcontrol; + } + } + return null; + } + + public Map<String, Observer> getObservers() { + if (observers == null) + observers = new HashMap<String, Observer>(); + return observers; + } + + public Observer getObserver(String observerID) { + return this.observers.get(observerID); + } + + public Boolean hasObserver(String ID) { + if (getObservers().containsKey(ID)) + return true; + return false; + } + + public void addObserver(Observer observer) { + observers.put(observer.getID(), (Observer) observer); + for (IObserverListener listener : getObserverListener()) { + listener.addedObserver(this, observer); + } + } + + public void removeObserver(String observerID) { + if (hasObserver(observerID)) + observers.get(observerID).beforeDelete(this); + observers.remove(observerID); + for (IObserverListener listener : getObserverListener()) { + listener.removedObserver(this); + } + } + + public Map<String, SchedulerEvent> getEvents() { + if (events == null) + events = new HashMap<String, SchedulerEvent>(); + return events; + } + + public SchedulerEvent getEvent(String ID) { + return events.get(ID); + } + + public Boolean hasEvent(String ID) { + if (getEvents().containsKey(ID)) + return true; + return false; + } + + public void addEvent(String eventID, SchedulerEvent schedulerEvent) { + events.put(eventID, schedulerEvent); + } + + public void removeEvent(String eventID) { + if (hasEvent(eventID)) + events.get(eventID).beforeDelete(this); + events.remove(eventID); + } + + public Map<String, AbstractAttribute> getAttributes() { + return attributes; + } + + public void setAttributes(Map<String, AbstractAttribute> attributes) { + this.attributes = attributes; + } + + public void setParent(BControl parent) { + this.parent = parent; + } + + public BControl getParent() { + return this.parent; + } + + public void addPropertyChangeListener(PropertyChangeListener listener) { + getListeners().addPropertyChangeListener(listener); + } + + public PropertyChangeSupport getListeners() { + if (listeners == null) + listeners = new PropertyChangeSupport(this); + return listeners; + } + + public void removePropertyChangeListener(PropertyChangeListener listener) { + getListeners().removePropertyChangeListener(listener); + } + + public Object getAdapter(@SuppressWarnings("rawtypes") Class adapter) { + if (adapter == IPropertySource.class) { + return new BControlPropertySource(this); + } + return null; + } + + public boolean contains(BControl child) { + return children.contains(child); + } + + public String getDefaultValue(String attributeID) { + + IConfigurationElement configurationElement = BMotionEditorPlugin + .getControlExtension(getType()); + + if (configurationElement != null) { + + for (final IConfigurationElement configBAttributes : configurationElement + .getChildren("attributes")) { + + for (final IConfigurationElement configBAttribute : configBAttributes + .getChildren("attribute-string")) { + + String aID = configBAttribute.getAttribute("id"); + + if (aID.equals(attributeID)) { + String attributeDefaultValue = configBAttribute + .getAttribute("default-value"); + + return attributeDefaultValue; + } + + } + + } + + } + + return null; + + } + + public Boolean isAttributeEditable(String attributeID) { + + IConfigurationElement configurationElement = BMotionEditorPlugin + .getControlExtension(getType()); + + if (configurationElement != null) { + + for (final IConfigurationElement configBAttributes : configurationElement + .getChildren("attributes")) { + + for (final IConfigurationElement configBAttribute : configBAttributes + .getChildren("attribute-string")) { + + String aID = configBAttribute.getAttribute("id"); + + if (aID.equals(attributeID)) { + String val = configBAttribute.getAttribute("editable"); + return Boolean.valueOf(val); + } + + } + + } + + } + + return false; + + } + + public Visualization getVisualization() { + return visualization; + } + + public void setVisualization(Visualization visualization) { + this.visualization = visualization; + } + + protected void populateVisualization(Visualization visualization) { + // Populate visualization node + setVisualization(visualization); + for (BControl child : getChildrenArray()) + child.populateVisualization(visualization); + for (BConnection con : getTargetConnections()) + con.populateVisualization(visualization); + for (BConnection con : getSourceConnections()) + con.populateVisualization(visualization); + } + + @Override + public BControl clone() throws CloneNotSupportedException { + + BControl clonedControl = (BControl) super.clone(); + + IConfigurationElement configElement = BMotionEditorPlugin + .getControlServices().get(getType()); + if (configElement != null) { + + try { + + IBControlService service = (IBControlService) configElement + .createExecutableExtension("service"); + clonedControl = service.createControl(visualization); + + clonedControl.setParent(getParent()); + + String newID = clonedControl.getID(); + + Map<String, AbstractAttribute> newProperties = new HashMap<String, AbstractAttribute>(); + for (Entry<String, AbstractAttribute> e : getAttributes() + .entrySet()) { + AbstractAttribute idAtr = e.getValue().clone(); + newProperties.put(e.getKey(), idAtr); + } + + clonedControl.setAttributes(newProperties); + clonedControl.setAttributeValue( + AttributeConstants.ATTRIBUTE_ID, newID); + + Iterator<BControl> it = getChildrenArray().iterator(); + while (it.hasNext()) { + clonedControl.addChild(((BControl) it.next()).clone()); + } + + for (Observer observer : observers.values()) { + clonedControl.addObserver(observer.clone()); + } + + for (Map.Entry<String, SchedulerEvent> e : events.entrySet()) { + clonedControl.addEvent(e.getKey(), e.getValue().clone()); + } + + } catch (CoreException e) { + e.printStackTrace(); + } + + } + + return clonedControl; + + } + + public void checkObserver(final Animation animation) { + + // Check all Observers + for (Observer observer : getObservers().values()) { + observer.check(animation, BControl.this); + } + + // TODO: Currently connection observer are checked twice (source + + // target) => change this, so that observer are checked only on time per + // state!!! + for (BConnection con : getSourceConnections()) { + con.checkObserver(animation); + } + for (BConnection con : getTargetConnections()) { + con.checkObserver(animation); + } + + // Check Observers of children + if (getChildrenArray().size() > 0) { + for (BControl bcontrol : getChildrenArray()) { + bcontrol.checkObserver(animation); + } + } + + } + + public void afterCheckObserver(Animation animation) { + // Check all Observers + for (Observer observer : getObservers().values()) { + observer.afterCheck(animation, this); + } + // Check Observers of children + if (getChildrenArray().size() > 0) { + for (BControl bcontrol : getChildrenArray()) { + bcontrol.afterCheckObserver(animation); + } + } + } + + public void executeEvent(String eventID) { + if (hasAttribute(AttributeConstants.ATTRIBUTE_ENABLED)) { + if (!(Boolean) getAttributeValue(AttributeConstants.ATTRIBUTE_ENABLED)) + return; + } + SchedulerEvent e = getEvents().get(eventID); + if (e != null) + e.execute(getVisualization().getAnimation(), this); + } + + public void setVerticalGuide(BMotionGuide verticalGuide) { + this.verticalGuide = verticalGuide; + } + + public BMotionGuide getVerticalGuide() { + return verticalGuide; + } + + public void setHorizontalGuide(BMotionGuide horizontalGuide) { + this.horizontalGuide = horizontalGuide; + } + + public BMotionGuide getHorizontalGuide() { + return horizontalGuide; + } + + /** + * @return the observerListener + */ + public ArrayList<IObserverListener> getObserverListener() { + if (observerListener == null) + observerListener = new ArrayList<IObserverListener>(); + return observerListener; + } + + public void addObserverListener(IObserverListener listener) { + getObserverListener().add(listener); + } + + public void removeObserverListener(IObserverListener listener) { + getObserverListener().remove(listener); + } + + /** + * Return a List of outgoing Connections. + */ + public List<BConnection> getSourceConnections() { + if (this.sourceConnections == null) + this.sourceConnections = new ArrayList<BConnection>(); + return this.sourceConnections; + } + + public void setSourceConnections(List<BConnection> connections) { + this.sourceConnections = connections; + } + + public void setTargetConnections(List<BConnection> connections) { + this.targetConnections = connections; + } + + /** + * Return a List of incoming Connections. + */ + public List<BConnection> getTargetConnections() { + if (this.targetConnections == null) + this.targetConnections = new ArrayList<BConnection>(); + return this.targetConnections; + } + + public boolean hasConnections() { + return !getTargetConnections().isEmpty() + || !getSourceConnections().isEmpty(); + } + + public boolean showInOutlineView() { + return true; + } + + public void setObserverMap(Map<String, Observer> observerMap) { + observers = observerMap; + } + + public void setEventMap(Map<String, SchedulerEvent> eventMap) { + events = eventMap; + } + + public abstract String getType(); + + protected void initAttribute(AbstractAttribute atr) { + getAttributes().put(atr.getID(), atr); + } + + protected void initAttribute(AbstractAttribute atr, AbstractAttribute group) { + initAttribute(atr, group.getClass().getName()); + } + + protected void initAttribute(AbstractAttribute atr, String group) { + atr.setGroup(group); + initAttribute(atr); + } + + public boolean canHaveChildren() { + return false; + } + + public String getValueOfData() { + return getAttributeValue(AttributeConstants.ATTRIBUTE_CUSTOM) + .toString(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/Observer.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/Observer.java index fde46fcd929494efa157fccee57e322db1e7cafb..ee4d33324d3f113322f5da7904d8bbc10e794a41 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/Observer.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/Observer.java @@ -1,103 +1,103 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - -import org.eclipse.core.runtime.IConfigurationElement; -import org.eclipse.draw2d.IFigure; - -import de.bmotionstudio.gef.editor.AbstractExpressionControl; -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.model.BControl; - -/** - * - * Observers are used to link controls to the model's state, i.e., they do the - * same as the animation function in ProB. The main difference is, that we allow - * to decompose the animation function into different aspects, i.e., if our - * model contains information about the speed of a motor, we can separate all - * information regarding the speed from the information regarding the - * temperature. This allows us to write small functions and combine them rather - * than writing a single function covering all aspects of the model. - * - * @author Lukas Ladenberger - * - */ -public abstract class Observer extends AbstractExpressionControl { - - // private transient Boolean callBack = false; - - public Observer() { - init(); - } - - protected Object readResolve() { - init(); - // callBack = false; - return this; - } - - /** - * Method to initialize the observer. Gets the ID, name and description from - * the corresponding extension point - */ - private void init() { - IConfigurationElement configElement = BMotionEditorPlugin - .getObserverExtension(getClass().getName()); - if (configElement != null) { - this.ID = configElement.getAttribute("class"); - this.name = configElement.getAttribute("name"); - this.description = configElement.getAttribute("description"); - } - } - - /** - * Makes a copy of the observer - * - * @return the cloned observer - */ - public Observer clone() throws CloneNotSupportedException { - return (Observer) super.clone(); - } - - // public void setCallBack(Boolean callBack) { - // this.callBack = callBack; - // } - // - // public Boolean isCallBack() { - // return callBack; - // } - - /** - * This method is called after every state change. The method tells the - * control how it has to look like and how to behave. - * - * @param animation - * The running animation - * @param bcontrol - * The corresponding control - * @throws BMotionObserverException - */ - public abstract void check(Animation animation, BControl control); - - /** - * Returns a corresponding wizard for the observer. - * - * @param bcontrol - * The corresponding control - * @return the corresponding wizard - */ - public abstract ObserverWizard getWizard(BControl control); - - public IFigure getToolTip(BControl control) { - return null; - } - - public void afterCheck(Animation animation, BControl control) { - } - -} +/** + * (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.bmotionstudio.gef.editor.observer; + +import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.draw2d.IFigure; + +import de.bmotionstudio.gef.editor.AbstractExpressionControl; +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.model.BControl; + +/** + * + * Observers are used to link controls to the model's state, i.e., they do the + * same as the animation function in ProB. The main difference is, that we allow + * to decompose the animation function into different aspects, i.e., if our + * model contains information about the speed of a motor, we can separate all + * information regarding the speed from the information regarding the + * temperature. This allows us to write small functions and combine them rather + * than writing a single function covering all aspects of the model. + * + * @author Lukas Ladenberger + * + */ +public abstract class Observer extends AbstractExpressionControl { + + // private transient Boolean callBack = false; + + public Observer() { + init(); + } + + protected Object readResolve() { + init(); + // callBack = false; + return this; + } + + /** + * Method to initialize the observer. Gets the ID, name and description from + * the corresponding extension point + */ + private void init() { + IConfigurationElement configElement = BMotionEditorPlugin + .getObserverExtension(getClass().getName()); + if (configElement != null) { + this.ID = configElement.getAttribute("class"); + this.name = configElement.getAttribute("name"); + this.description = configElement.getAttribute("description"); + } + } + + /** + * Makes a copy of the observer + * + * @return the cloned observer + */ + public Observer clone() throws CloneNotSupportedException { + return (Observer) super.clone(); + } + + // public void setCallBack(Boolean callBack) { + // this.callBack = callBack; + // } + // + // public Boolean isCallBack() { + // return callBack; + // } + + /** + * This method is called after every state change. The method tells the + * control how it has to look like and how to behave. + * + * @param animation + * The running animation + * @param bcontrol + * The corresponding control + * @throws BMotionObserverException + */ + public abstract void check(Animation animation, BControl control); + + /** + * Returns a corresponding wizard for the observer. + * + * @param bcontrol + * The corresponding control + * @return the corresponding wizard + */ + public abstract ObserverWizard getWizard(BControl control); + + public IFigure getToolTip(BControl control) { + return null; + } + + public void afterCheck(Animation animation, BControl control) { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ObserverWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ObserverWizard.java index ddddd919b5fc189a350fc4fc783d7a19d1479717..d480959943c777c965b5d7d2a38b9b62be9a8cfc 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ObserverWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ObserverWizard.java @@ -1,60 +1,58 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - -import org.eclipse.jface.wizard.Wizard; -import org.eclipse.swt.graphics.Point; - -import de.bmotionstudio.gef.editor.model.BControl; - -/** - * - * The BMotion Studio provides an easy way to handle Observers. For this, - * Observers can have a corresponding wizard. The user can open it by calling - * the context menu of a Control. - * - * @author Lukas Ladenberger - * - */ -public abstract class ObserverWizard extends Wizard { - - private BControl control; - private Observer observer; - - protected Boolean observerDelete = false; - - public ObserverWizard(BControl control, Observer observer) { - this.control = control; - this.observer = observer; - } - - public BControl getBControl() { - return this.control; - } - - public Observer getObserver() { - return this.observer; - } - - protected void setObserverDelete(Boolean b) { - this.observerDelete = b; - } - - protected abstract Boolean prepareToFinish(); - - @Override - public boolean performFinish() { - return prepareToFinish(); - } - - public Boolean isObserverDelete() { - return this.observerDelete; - } - - public abstract Point getSize(); - -} +/** + * (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.bmotionstudio.gef.editor.observer; + +import org.eclipse.swt.graphics.Point; + +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; +import de.bmotionstudio.gef.editor.model.BControl; + +/** + * + * The BMotion Studio provides an easy way to handle Observers. For this, + * Observers can have a corresponding wizard. The user can open it by calling + * the context menu of a Control. + * + * @author Lukas Ladenberger + * + */ +public abstract class ObserverWizard extends BMotionAbstractWizard { + + private BControl control; + private Observer observer; + + protected Boolean observerDelete = false; + + public ObserverWizard(BControl control, Observer observer) { + this.control = control; + this.observer = observer; + } + + public BControl getBControl() { + return this.control; + } + + public Observer getObserver() { + return this.observer; + } + + protected void setObserverDelete(Boolean b) { + this.observerDelete = b; + } + + public Boolean isObserverDelete() { + return this.observerDelete; + } + + public abstract Point getSize(); + + @Override + public String getName() { + return observer.getName(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SimpleValueDisplay.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SimpleValueDisplay.java index a6934ec7539ce6f1fc3c4063dcb0d3bc8804a60e..832c98aa9b149c3c930e42af3d4b08ef7760783c 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SimpleValueDisplay.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SimpleValueDisplay.java @@ -1,100 +1,100 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverSimpleValueDisplay; - -public class SimpleValueDisplay extends Observer { - - private String type; - private String eval; - private String predicate; - private String replacementString; - private transient String orgString; - private transient boolean isOrgStringSet = false; - - public void check(final Animation animation, final BControl bcontrol) { - - // First evaluate predicate (predicate field) - String bolValue = "true"; - if (predicate != null && predicate.length() > 0) { - bolValue = parsePredicate(predicate, bcontrol, animation, null); - } - - if (Boolean.valueOf(bolValue)) { - - String fEval = parseExpression(eval, bcontrol, animation, null); - - if (!isOrgStringSet) { - orgString = bcontrol.getAttributeValue( - AttributeConstants.ATTRIBUTE_TEXT).toString(); - isOrgStringSet = true; - } - - String parseString = orgString; - - if (replacementString != null) { - if (replacementString.length() > 0) { - parseString = orgString.replace(replacementString, fEval); - } - } else { - parseString = fEval; - } - - bcontrol.setAttributeValue(AttributeConstants.ATTRIBUTE_TEXT, - parseString); - - } - - } - - public ObserverWizard getWizard(final BControl bcontrol) { - return new WizardObserverSimpleValueDisplay(bcontrol, this); - } - - public String getType() { - return type; - } - - public void setType(String type) { - this.type = type; - } - - public void setEval(String eval) { - this.eval = eval; - } - - public String getEval() { - return eval; - } - - public String getPredicate() { - return predicate; - } - - public void setPredicate(String predicate) { - this.predicate = predicate; - } - - public void setReplacementString(String replacementString) { - this.replacementString = replacementString; - } - - public String getReplacementString() { - return replacementString; - } - - public Observer clone() throws CloneNotSupportedException { - SimpleValueDisplay clonedObserver = (SimpleValueDisplay) super.clone(); - clonedObserver.isOrgStringSet = false; - return clonedObserver; - } - -} +/** + * (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.bmotionstudio.gef.editor.observer; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverSimpleValueDisplay; + +public class SimpleValueDisplay extends Observer { + + private String type; + private String eval; + private String predicate; + private String replacementString; + private transient String orgString; + private transient boolean isOrgStringSet = false; + + public void check(final Animation animation, final BControl bcontrol) { + + // First evaluate predicate (predicate field) + String bolValue = "true"; + if (predicate != null && predicate.length() > 0) { + bolValue = parsePredicate(predicate, bcontrol, animation, null); + } + + if (Boolean.valueOf(bolValue)) { + + String fEval = parseExpression(eval, bcontrol, animation, null); + + if (!isOrgStringSet) { + orgString = bcontrol.getAttributeValue( + AttributeConstants.ATTRIBUTE_TEXT).toString(); + isOrgStringSet = true; + } + + String parseString = orgString; + + if (replacementString != null) { + if (replacementString.length() > 0) { + parseString = orgString.replace(replacementString, fEval); + } + } else { + parseString = fEval; + } + + bcontrol.setAttributeValue(AttributeConstants.ATTRIBUTE_TEXT, + parseString); + + } + + } + + public ObserverWizard getWizard(final BControl bcontrol) { + return new WizardObserverSimpleValueDisplay(bcontrol, this); + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public void setEval(String eval) { + this.eval = eval; + } + + public String getEval() { + return eval; + } + + public String getPredicate() { + return predicate; + } + + public void setPredicate(String predicate) { + this.predicate = predicate; + } + + public void setReplacementString(String replacementString) { + this.replacementString = replacementString; + } + + public String getReplacementString() { + return replacementString; + } + + public Observer clone() throws CloneNotSupportedException { + SimpleValueDisplay clonedObserver = (SimpleValueDisplay) super.clone(); + clonedObserver.isOrgStringSet = false; + return clonedObserver; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchChildCoordinates.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchChildCoordinates.java index 273f37ab987e3dc546df27579f31aaef5c16e8c9..87f109d42fa988d24576c35a9a4286d551334b8f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchChildCoordinates.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchChildCoordinates.java @@ -1,147 +1,147 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - -import java.util.ArrayList; -import java.util.List; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.animation.AnimationMove; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverCSwitchCoordinates; - -public class SwitchChildCoordinates extends Observer { - - private List<ToggleObjectCoordinates> toggleObjects; - - // private transient AnimationListener animationListener; - - // private transient Boolean checked; - - public SwitchChildCoordinates() { - toggleObjects = new ArrayList<ToggleObjectCoordinates>(); - } - - public void check(final Animation animation, final BControl control) { - - // if (checked == null) - // checked = true; - // - // if (!checked) - // return; - // - // if (animationListener == null) { - // animationListener = new AnimationListener() { - // public void animationStopped(AnimationEvent evt) { - // setCallBack(true); - // // checked = true; - // } - // - // public void animationStarted(AnimationEvent evt) { - // setCallBack(false); - // checked = false; - // } - // }; - // } - - // Collect evaluate predicate objects in list - for (ToggleObjectCoordinates obj : toggleObjects) { - - obj.setHasError(false); - - // First evaluate predicate (predicate field) - String bolValue = "true"; - if (obj.getEval().length() > 0) { - bolValue = parsePredicate(obj.getEval(), control, animation, - obj); - } - - if (!obj.hasError() && Boolean.valueOf(bolValue)) { - - // Handle control field - BControl toggleControl = null; - String parsedControl = parseExpression(obj.getBcontrol(), - false, control, animation, obj, false); - toggleControl = control.getChild(parsedControl); - if (toggleControl == null) { - obj.setHasError(true); - addError(control, animation, "No such control: " - + parsedControl); - } - - Integer parsedX = 0; - Integer parsedY = 0; - // Handle X field - try { - parsedX = Integer.valueOf(parseExpression(obj.getX(), - false, control, animation, obj, false)); - } catch (NumberFormatException n) { - obj.setHasError(true); - addError(control, animation, "x is not a valid integer: " - + n.getMessage()); - } - // Handle Y field - try { - parsedY = Integer.valueOf(parseExpression(obj.getY(), - false, control, animation, obj, false)); - } catch (NumberFormatException n) { - obj.setHasError(true); - addError(control, animation, "y is not a valid integer: " - + n.getMessage()); - } - - if (!obj.hasError()) { - if (Boolean.valueOf(bolValue)) { // If true - if (obj.getAnimate()) { - - AnimationMove aMove = new AnimationMove(500, true, - toggleControl, parsedX, parsedY); - // aMove.addAnimationListener(animationListener); - aMove.start(); - - } else { - - toggleControl.setAttributeValue( - AttributeConstants.ATTRIBUTE_X, parsedX); - toggleControl.setAttributeValue( - AttributeConstants.ATTRIBUTE_Y, parsedY); - - } - } - } - - } - - } - - } - - public ObserverWizard getWizard(final BControl bcontrol) { - return new WizardObserverCSwitchCoordinates(bcontrol, this); - } - - public List<ToggleObjectCoordinates> getToggleObjects() { - return this.toggleObjects; - } - - public void setToggleObjects(final List<ToggleObjectCoordinates> list) { - this.toggleObjects = list; - } - - public Observer clone() throws CloneNotSupportedException { - SwitchChildCoordinates clonedObserver = (SwitchChildCoordinates) super - .clone(); - List<ToggleObjectCoordinates> list = new ArrayList<ToggleObjectCoordinates>(); - for (ToggleObjectCoordinates obj : getToggleObjects()) { - list.add(obj.clone()); - } - clonedObserver.setToggleObjects(list); - return clonedObserver; - } - -} +/** + * (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.bmotionstudio.gef.editor.observer; + +import java.util.ArrayList; +import java.util.List; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.animation.AnimationMove; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverCSwitchCoordinates; + +public class SwitchChildCoordinates extends Observer { + + private List<ToggleObjectCoordinates> toggleObjects; + + // private transient AnimationListener animationListener; + + // private transient Boolean checked; + + public SwitchChildCoordinates() { + toggleObjects = new ArrayList<ToggleObjectCoordinates>(); + } + + public void check(final Animation animation, final BControl control) { + + // if (checked == null) + // checked = true; + // + // if (!checked) + // return; + // + // if (animationListener == null) { + // animationListener = new AnimationListener() { + // public void animationStopped(AnimationEvent evt) { + // setCallBack(true); + // // checked = true; + // } + // + // public void animationStarted(AnimationEvent evt) { + // setCallBack(false); + // checked = false; + // } + // }; + // } + + // Collect evaluate predicate objects in list + for (ToggleObjectCoordinates obj : toggleObjects) { + + obj.setHasError(false); + + // First evaluate predicate (predicate field) + String bolValue = "true"; + if (obj.getEval().length() > 0) { + bolValue = parsePredicate(obj.getEval(), control, animation, + obj); + } + + if (!obj.hasError() && Boolean.valueOf(bolValue)) { + + // Handle control field + BControl toggleControl = null; + String parsedControl = parseExpression(obj.getBcontrol(), + false, control, animation, obj, false); + toggleControl = control.getChild(parsedControl); + if (toggleControl == null) { + obj.setHasError(true); + addError(control, animation, "No such control: " + + parsedControl); + } + + Integer parsedX = 0; + Integer parsedY = 0; + // Handle X field + try { + parsedX = Integer.valueOf(parseExpression(obj.getX(), + false, control, animation, obj, false)); + } catch (NumberFormatException n) { + obj.setHasError(true); + addError(control, animation, "x is not a valid integer: " + + n.getMessage()); + } + // Handle Y field + try { + parsedY = Integer.valueOf(parseExpression(obj.getY(), + false, control, animation, obj, false)); + } catch (NumberFormatException n) { + obj.setHasError(true); + addError(control, animation, "y is not a valid integer: " + + n.getMessage()); + } + + if (!obj.hasError()) { + if (Boolean.valueOf(bolValue)) { // If true + if (obj.getAnimate()) { + + AnimationMove aMove = new AnimationMove(500, true, + toggleControl, parsedX, parsedY); + // aMove.addAnimationListener(animationListener); + aMove.start(); + + } else { + + toggleControl.setAttributeValue( + AttributeConstants.ATTRIBUTE_X, parsedX); + toggleControl.setAttributeValue( + AttributeConstants.ATTRIBUTE_Y, parsedY); + + } + } + } + + } + + } + + } + + public ObserverWizard getWizard(final BControl bcontrol) { + return new WizardObserverCSwitchCoordinates(bcontrol, this); + } + + public List<ToggleObjectCoordinates> getToggleObjects() { + return this.toggleObjects; + } + + public void setToggleObjects(final List<ToggleObjectCoordinates> list) { + this.toggleObjects = list; + } + + public Observer clone() throws CloneNotSupportedException { + SwitchChildCoordinates clonedObserver = (SwitchChildCoordinates) super + .clone(); + List<ToggleObjectCoordinates> list = new ArrayList<ToggleObjectCoordinates>(); + for (ToggleObjectCoordinates obj : getToggleObjects()) { + list.add(obj.clone()); + } + clonedObserver.setToggleObjects(list); + return clonedObserver; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchCoordinates.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchCoordinates.java index 10ec1ecce5a9f5337d31be76d23084352fd8b0dc..8312e52f2da2bda2f91f15ffcab68103e01a0621 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchCoordinates.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchCoordinates.java @@ -1,159 +1,159 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - -import java.util.ArrayList; -import java.util.List; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.animation.AnimationMove; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverSwitchCoordinates; - -public class SwitchCoordinates extends Observer { - - private List<ToggleObjectCoordinates> toggleObjects; - - // private transient AnimationListener animationListener; - - // private transient Boolean checked; - - public SwitchCoordinates() { - toggleObjects = new ArrayList<ToggleObjectCoordinates>(); - } - - public void check(final Animation animation, final BControl control) { - - boolean set = false; - - // if (checked == null) - // checked = true; - - // if (animationListener == null) { - // animationListener = new AnimationListener() { - // public void animationStopped(AnimationEvent evt) { - // setCallBack(true); - // checked = true; - // // System.out - // // .println("Animation stopped ---> Set callback to TRUE!"); - // } - // - // public void animationStarted(AnimationEvent evt) { - // setCallBack(false); - // checked = false; - // // System.out - // // .println("Animation started ---> Set callback to FALSE!"); - // } - // }; - // } - - // Collect evaluate predicate objects in list - for (ToggleObjectCoordinates obj : toggleObjects) { - - obj.setHasError(false); - - // First evaluate predicate (predicate field) - String bolValue = "true"; - if (obj.getEval().length() > 0) { - bolValue = parsePredicate(obj.getEval(), control, animation, - obj); - } - - if (!obj.hasError() && Boolean.valueOf(bolValue)) { - - int parsedX = 0; - int parsedY = 0; - // Handle X field - try { - parsedX = Integer.valueOf(parseExpression(obj.getX(), - false, control, animation, obj, false)); - } catch (NumberFormatException n) { - obj.setHasError(true); - addError(control, animation, "x is not a valid integer: " - + n.getMessage()); - } - // Handle Y field - try { - parsedY = Integer.valueOf(parseExpression(obj.getY(), - false, control, animation, obj, false)); - } catch (NumberFormatException n) { - obj.setHasError(true); - addError(control, animation, "y is not a valid integer: " - + n.getMessage()); - } - - int currentX = Integer.valueOf(control.getAttributeValue( - AttributeConstants.ATTRIBUTE_X).toString()); - int currentY = Integer.valueOf(control.getAttributeValue( - AttributeConstants.ATTRIBUTE_Y).toString()); - - if (currentX != parsedX || currentY != parsedY) { - - // setCallBack(false); - - // If true - if (obj.getAnimate()) { - - // if (!checked) - // return; - - AnimationMove aMove = new AnimationMove(5000, true, - control, parsedX, parsedY); - // aMove.addAnimationListener(animationListener); - aMove.start(); - - } else { - control.setAttributeValue( - AttributeConstants.ATTRIBUTE_X, parsedX); - control.setAttributeValue( - AttributeConstants.ATTRIBUTE_Y, parsedY); - // setCallBack(true); - // checked = false; - } - - } - // else { - // setCallBack(true); - // } - - set = true; - - } - - } - - if (!set) { - control.restoreDefaultValue(AttributeConstants.ATTRIBUTE_X); - control.restoreDefaultValue(AttributeConstants.ATTRIBUTE_Y); - } - - } - - public ObserverWizard getWizard(final BControl bcontrol) { - return new WizardObserverSwitchCoordinates(bcontrol, this); - } - - public List<ToggleObjectCoordinates> getToggleObjects() { - return this.toggleObjects; - } - - public void setToggleObjects(final List<ToggleObjectCoordinates> list) { - this.toggleObjects = list; - } - - public Observer clone() throws CloneNotSupportedException { - SwitchCoordinates clonedObserver = (SwitchCoordinates) super.clone(); - List<ToggleObjectCoordinates> list = new ArrayList<ToggleObjectCoordinates>(); - for (ToggleObjectCoordinates obj : getToggleObjects()) { - list.add(obj.clone()); - } - clonedObserver.setToggleObjects(list); - return clonedObserver; - } - -} +/** + * (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.bmotionstudio.gef.editor.observer; + +import java.util.ArrayList; +import java.util.List; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.animation.AnimationMove; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverSwitchCoordinates; + +public class SwitchCoordinates extends Observer { + + private List<ToggleObjectCoordinates> toggleObjects; + + // private transient AnimationListener animationListener; + + // private transient Boolean checked; + + public SwitchCoordinates() { + toggleObjects = new ArrayList<ToggleObjectCoordinates>(); + } + + public void check(final Animation animation, final BControl control) { + + boolean set = false; + + // if (checked == null) + // checked = true; + + // if (animationListener == null) { + // animationListener = new AnimationListener() { + // public void animationStopped(AnimationEvent evt) { + // setCallBack(true); + // checked = true; + // // System.out + // // .println("Animation stopped ---> Set callback to TRUE!"); + // } + // + // public void animationStarted(AnimationEvent evt) { + // setCallBack(false); + // checked = false; + // // System.out + // // .println("Animation started ---> Set callback to FALSE!"); + // } + // }; + // } + + // Collect evaluate predicate objects in list + for (ToggleObjectCoordinates obj : toggleObjects) { + + obj.setHasError(false); + + // First evaluate predicate (predicate field) + String bolValue = "true"; + if (obj.getEval().length() > 0) { + bolValue = parsePredicate(obj.getEval(), control, animation, + obj); + } + + if (!obj.hasError() && Boolean.valueOf(bolValue)) { + + int parsedX = 0; + int parsedY = 0; + // Handle X field + try { + parsedX = Integer.valueOf(parseExpression(obj.getX(), + false, control, animation, obj, false)); + } catch (NumberFormatException n) { + obj.setHasError(true); + addError(control, animation, "x is not a valid integer: " + + n.getMessage()); + } + // Handle Y field + try { + parsedY = Integer.valueOf(parseExpression(obj.getY(), + false, control, animation, obj, false)); + } catch (NumberFormatException n) { + obj.setHasError(true); + addError(control, animation, "y is not a valid integer: " + + n.getMessage()); + } + + int currentX = Integer.valueOf(control.getAttributeValue( + AttributeConstants.ATTRIBUTE_X).toString()); + int currentY = Integer.valueOf(control.getAttributeValue( + AttributeConstants.ATTRIBUTE_Y).toString()); + + if (currentX != parsedX || currentY != parsedY) { + + // setCallBack(false); + + // If true + if (obj.getAnimate()) { + + // if (!checked) + // return; + + AnimationMove aMove = new AnimationMove(5000, true, + control, parsedX, parsedY); + // aMove.addAnimationListener(animationListener); + aMove.start(); + + } else { + control.setAttributeValue( + AttributeConstants.ATTRIBUTE_X, parsedX); + control.setAttributeValue( + AttributeConstants.ATTRIBUTE_Y, parsedY); + // setCallBack(true); + // checked = false; + } + + } + // else { + // setCallBack(true); + // } + + set = true; + + } + + } + + if (!set) { + control.restoreDefaultValue(AttributeConstants.ATTRIBUTE_X); + control.restoreDefaultValue(AttributeConstants.ATTRIBUTE_Y); + } + + } + + public ObserverWizard getWizard(final BControl bcontrol) { + return new WizardObserverSwitchCoordinates(bcontrol, this); + } + + public List<ToggleObjectCoordinates> getToggleObjects() { + return this.toggleObjects; + } + + public void setToggleObjects(final List<ToggleObjectCoordinates> list) { + this.toggleObjects = list; + } + + public Observer clone() throws CloneNotSupportedException { + SwitchCoordinates clonedObserver = (SwitchCoordinates) super.clone(); + List<ToggleObjectCoordinates> list = new ArrayList<ToggleObjectCoordinates>(); + for (ToggleObjectCoordinates obj : getToggleObjects()) { + list.add(obj.clone()); + } + clonedObserver.setToggleObjects(list); + return clonedObserver; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchImage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchImage.java index 38bd1896e469f31c4b147662358ce619c0c799fe..2af5974ceb542cc8ddd5935e8c8d7b2f7b048dec 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchImage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/SwitchImage.java @@ -1,102 +1,102 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - -import java.io.File; -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.core.resources.IFile; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverSwitchImage; - -public class SwitchImage extends Observer { - - private List<ToggleObjectImage> toggleObjects; - - public SwitchImage() { - toggleObjects = new ArrayList<ToggleObjectImage>(); - } - - public void check(final Animation animation, final BControl control) { - - boolean set = false; - - // Collect evaluate predicate objects in list - for (ToggleObjectImage obj : toggleObjects) { - - obj.setHasError(false); - - // First evaluate predicate (predicate field) - String bolValue = "true"; - if (obj.getEval().length() > 0) { - bolValue = parsePredicate(obj.getEval(), control, animation, - obj); - } - - if (!obj.hasError() && Boolean.valueOf(bolValue)) { - - String fImage = obj.getImage(); - - if (obj.isExpressionMode()) { // Expression mode - fImage = parseExpression(obj.getImage(), control, - animation, obj); - } - - IFile pFile = control.getVisualization().getProjectFile(); - String myPath = (pFile.getProject().getLocation() + "/images/" + fImage) - .replace("file:", ""); - if (!new File(myPath).exists()) { - addError(control, animation, - "No such image in your library: " + fImage); - } - - if (!obj.hasError()) { - if (!control.getAttributeValue( - AttributeConstants.ATTRIBUTE_IMAGE).equals(fImage)) { - control.setAttributeValue( - AttributeConstants.ATTRIBUTE_IMAGE, fImage); - } - } - - set = true; - - } - - } - - if (!set) - control.restoreDefaultValue(AttributeConstants.ATTRIBUTE_IMAGE); - - } - - public ObserverWizard getWizard(final BControl bcontrol) { - return new WizardObserverSwitchImage(bcontrol, this); - } - - public List<ToggleObjectImage> getToggleObjects() { - return this.toggleObjects; - } - - public void setToggleObjects(final List<ToggleObjectImage> list) { - this.toggleObjects = list; - } - - public Observer clone() throws CloneNotSupportedException { - SwitchImage clonedObserver = (SwitchImage) super.clone(); - List<ToggleObjectImage> list = new ArrayList<ToggleObjectImage>(); - for (ToggleObjectImage obj : getToggleObjects()) { - list.add(obj.clone()); - } - clonedObserver.setToggleObjects(list); - return clonedObserver; - } - -} +/** + * (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.bmotionstudio.gef.editor.observer; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.resources.IFile; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverSwitchImage; + +public class SwitchImage extends Observer { + + private List<ToggleObjectImage> toggleObjects; + + public SwitchImage() { + toggleObjects = new ArrayList<ToggleObjectImage>(); + } + + public void check(final Animation animation, final BControl control) { + + boolean set = false; + + // Collect evaluate predicate objects in list + for (ToggleObjectImage obj : toggleObjects) { + + obj.setHasError(false); + + // First evaluate predicate (predicate field) + String bolValue = "true"; + if (obj.getEval().length() > 0) { + bolValue = parsePredicate(obj.getEval(), control, animation, + obj); + } + + if (!obj.hasError() && Boolean.valueOf(bolValue)) { + + String fImage = obj.getImage(); + + if (obj.isExpressionMode()) { // Expression mode + fImage = parseExpression(obj.getImage(), control, + animation, obj); + } + + IFile pFile = control.getVisualization().getProjectFile(); + String myPath = (pFile.getProject().getLocation() + "/images/" + fImage) + .replace("file:", ""); + if (!new File(myPath).exists()) { + addError(control, animation, + "No such image in your library: " + fImage); + } + + if (!obj.hasError()) { + if (!control.getAttributeValue( + AttributeConstants.ATTRIBUTE_IMAGE).equals(fImage)) { + control.setAttributeValue( + AttributeConstants.ATTRIBUTE_IMAGE, fImage); + } + } + + set = true; + + } + + } + + if (!set) + control.restoreDefaultValue(AttributeConstants.ATTRIBUTE_IMAGE); + + } + + public ObserverWizard getWizard(final BControl bcontrol) { + return new WizardObserverSwitchImage(bcontrol, this); + } + + public List<ToggleObjectImage> getToggleObjects() { + return this.toggleObjects; + } + + public void setToggleObjects(final List<ToggleObjectImage> list) { + this.toggleObjects = list; + } + + public Observer clone() throws CloneNotSupportedException { + SwitchImage clonedObserver = (SwitchImage) super.clone(); + List<ToggleObjectImage> list = new ArrayList<ToggleObjectImage>(); + for (ToggleObjectImage obj : getToggleObjects()) { + list.add(obj.clone()); + } + clonedObserver.setToggleObjects(list); + return clonedObserver; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ToggleObjectImage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ToggleObjectImage.java index 5169e967a6ec6bf3c06612d5219e952bba40aff2..dcd321623e5df59845f339638bacee19a1b31cba 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ToggleObjectImage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/ToggleObjectImage.java @@ -1,36 +1,36 @@ -/** - * (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.bmotionstudio.gef.editor.observer; - - -public class ToggleObjectImage extends ObserverEvalObject implements Cloneable { - - private String image; - - public ToggleObjectImage() { - } - - public ToggleObjectImage(String type, String image, String eval) { - super(type, eval); - this.image = image; - } - - public String getImage() { - return image; - } - - public void setImage(String image) { - Object oldValue = this.image; - this.image = image; - firePropertyChange("image", oldValue, this.image); - } - - public ToggleObjectImage clone() throws CloneNotSupportedException { - return (ToggleObjectImage) super.clone(); - } - -} +/** + * (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.bmotionstudio.gef.editor.observer; + + +public class ToggleObjectImage extends ObserverEvalObject implements Cloneable { + + private String image; + + public ToggleObjectImage() { + } + + public ToggleObjectImage(String type, String image, String eval) { + super(type, eval); + this.image = image; + } + + public String getImage() { + return image; + } + + public void setImage(String image) { + Object oldValue = this.image; + this.image = image; + firePropertyChange("image", oldValue, this.image); + } + + public ToggleObjectImage clone() throws CloneNotSupportedException { + return (ToggleObjectImage) super.clone(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverCSwitchCoordinates.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverCSwitchCoordinates.java index 4b5d60ba5405ff3692fea523b69d5390958e838e..48002be9092b2f094f42efc5e28ed6ecb81bd075 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverCSwitchCoordinates.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverCSwitchCoordinates.java @@ -41,6 +41,7 @@ import org.eclipse.swt.widgets.Display; import de.be4.classicalb.core.parser.BParser; import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.EditorImageRegistry; import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; @@ -52,7 +53,7 @@ import de.bmotionstudio.gef.editor.observer.ObserverWizard; import de.bmotionstudio.gef.editor.observer.SwitchChildCoordinates; import de.bmotionstudio.gef.editor.observer.ToggleObjectCoordinates; import de.bmotionstudio.gef.editor.property.CheckboxCellEditorHelper; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class WizardObserverCSwitchCoordinates extends ObserverWizard { @@ -73,9 +74,9 @@ public class WizardObserverCSwitchCoordinates extends ObserverWizard { Composite container = new Composite(parent, SWT.NONE); container.setLayout(new GridLayout(1, true)); - tableViewer = WizardObserverUtil.createObserverWizardTableViewer( + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( container, ToggleObjectCoordinates.class, - (ObserverWizard) getWizard()); + ((BMotionAbstractWizard) getWizard()).getName()); tableViewer .addSelectionChangedListener(new ISelectionChangedListener() { diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDragListener.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDragListener.java index 45b1c1addd31f3ce940c0a33f9dd31ffe5638491..69554add9f7ac05047108fba97e76f06dca4915f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDragListener.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDragListener.java @@ -1,37 +1,37 @@ -/** - * (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.bmotionstudio.gef.editor.observer.wizard; - -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.swt.dnd.DragSourceEvent; -import org.eclipse.swt.dnd.DragSourceListener; - -public class WizardObserverDragListener implements DragSourceListener { - - private final TableViewer viewer; - - public WizardObserverDragListener(TableViewer viewer) { - this.viewer = viewer; - } - - @Override - public void dragFinished(DragSourceEvent event) { - } - - @Override - public void dragSetData(DragSourceEvent event) { - IStructuredSelection selection = (IStructuredSelection) viewer - .getSelection(); - Object[] lobjects = selection.toArray(); - event.data = lobjects; - } - - @Override - public void dragStart(DragSourceEvent event) { - } - +/** + * (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.bmotionstudio.gef.editor.observer.wizard; + +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.swt.dnd.DragSourceEvent; +import org.eclipse.swt.dnd.DragSourceListener; + +public class WizardObserverDragListener implements DragSourceListener { + + private final TableViewer viewer; + + public WizardObserverDragListener(TableViewer viewer) { + this.viewer = viewer; + } + + @Override + public void dragFinished(DragSourceEvent event) { + } + + @Override + public void dragSetData(DragSourceEvent event) { + IStructuredSelection selection = (IStructuredSelection) viewer + .getSelection(); + Object[] lobjects = selection.toArray(); + event.data = lobjects; + } + + @Override + public void dragStart(DragSourceEvent event) { + } + } \ No newline at end of file diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDropListener.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDropListener.java index b9d4c121b3cf3185f749bc15d2a9444b2df990e9..60ddc0b7291b730cf45440468af27c5c8fe7a74b 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDropListener.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverDropListener.java @@ -1,94 +1,94 @@ -/** - * (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.bmotionstudio.gef.editor.observer.wizard; - -import org.eclipse.core.databinding.observable.list.WritableList; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.jface.viewers.Viewer; -import org.eclipse.jface.viewers.ViewerDropAdapter; -import org.eclipse.swt.dnd.DropTargetEvent; -import org.eclipse.swt.dnd.TransferData; -import org.eclipse.swt.widgets.Display; - -import de.bmotionstudio.gef.editor.observer.ObserverEvalObject; - -public class WizardObserverDropListener extends ViewerDropAdapter { - - private String observerName; - - public WizardObserverDropListener(Viewer viewer, String observerName) { - super(viewer); - this.observerName = observerName; - } - - @Override - public void drop(DropTargetEvent event) { - - Object[] sourceSetAttributeObjects = (Object[]) event.data; - Object targetSetAttributeObject = determineTarget(event); - - Object input = getViewer().getInput(); - if (input instanceof WritableList) { - - WritableList list = (WritableList) input; - - for (Object sourceObject : sourceSetAttributeObjects) { - - if (sourceObject instanceof ObserverEvalObject) { - - ObserverEvalObject sourceEvalObject = (ObserverEvalObject) sourceObject; - - if (sourceObject.getClass().equals(list.getElementType())) { - - int indexOf = list.indexOf(targetSetAttributeObject); - if (indexOf == -1) - indexOf = 0; - ObserverEvalObject newElement = sourceEvalObject; - if (!list.remove(sourceEvalObject)) { - try { - newElement = sourceEvalObject.clone(); - } catch (CloneNotSupportedException e) { - e.printStackTrace(); - } - } - - list.add(indexOf, newElement); - - } else { - - MessageDialog.openInformation(Display.getDefault() - .getActiveShell(), - "Drag and Drop is not supported", - "It is not possible to add an item of the type " - + sourceEvalObject.getClass() - + " to the observer \"" + observerName - + "\"."); - - } - - } - - } - - } - - super.drop(event); - - } - - @Override - public boolean performDrop(Object data) { - return false; - } - - @Override - public boolean validateDrop(Object target, int operation, - TransferData transferType) { - return true; - - } - -} +/** + * (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.bmotionstudio.gef.editor.observer.wizard; + +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.Viewer; +import org.eclipse.jface.viewers.ViewerDropAdapter; +import org.eclipse.swt.dnd.DropTargetEvent; +import org.eclipse.swt.dnd.TransferData; +import org.eclipse.swt.widgets.Display; + +import de.bmotionstudio.gef.editor.observer.ObserverEvalObject; + +public class WizardObserverDropListener extends ViewerDropAdapter { + + private String observerName; + + public WizardObserverDropListener(Viewer viewer, String observerName) { + super(viewer); + this.observerName = observerName; + } + + @Override + public void drop(DropTargetEvent event) { + + Object[] sourceSetAttributeObjects = (Object[]) event.data; + Object targetSetAttributeObject = determineTarget(event); + + Object input = getViewer().getInput(); + if (input instanceof WritableList) { + + WritableList list = (WritableList) input; + + for (Object sourceObject : sourceSetAttributeObjects) { + + if (sourceObject instanceof ObserverEvalObject) { + + ObserverEvalObject sourceEvalObject = (ObserverEvalObject) sourceObject; + + if (sourceObject.getClass().equals(list.getElementType())) { + + int indexOf = list.indexOf(targetSetAttributeObject); + if (indexOf == -1) + indexOf = 0; + ObserverEvalObject newElement = sourceEvalObject; + if (!list.remove(sourceEvalObject)) { + try { + newElement = sourceEvalObject.clone(); + } catch (CloneNotSupportedException e) { + e.printStackTrace(); + } + } + + list.add(indexOf, newElement); + + } else { + + MessageDialog.openInformation(Display.getDefault() + .getActiveShell(), + "Drag and Drop is not supported", + "It is not possible to add an item of the type " + + sourceEvalObject.getClass() + + " to the observer \"" + observerName + + "\"."); + + } + + } + + } + + } + + super.drop(event); + + } + + @Override + public boolean performDrop(Object data) { + return false; + } + + @Override + public boolean validateDrop(Object target, int operation, + TransferData transferType) { + return true; + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverListenOperationByPredicate.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverListenOperationByPredicate.java index fc8c82ee37d87c542bb75f3a76c6daa2b2182e4d..5042f6a77c25818953c8acc3e05b6b58ae22affd 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverListenOperationByPredicate.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverListenOperationByPredicate.java @@ -45,6 +45,7 @@ import org.eclipse.swt.layout.RowLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Composite; +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.EditorImageRegistry; import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; @@ -58,7 +59,7 @@ import de.bmotionstudio.gef.editor.observer.Observer; import de.bmotionstudio.gef.editor.observer.ObserverWizard; import de.bmotionstudio.gef.editor.property.CheckboxCellEditorHelper; import de.bmotionstudio.gef.editor.scheduler.PredicateOperation; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class WizardObserverListenOperationByPredicate extends ObserverWizard { @@ -79,9 +80,9 @@ public class WizardObserverListenOperationByPredicate extends ObserverWizard { setControl(container); - tableViewer = WizardObserverUtil.createObserverWizardTableViewer( + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( container, PredicateOperation.class, - (ObserverWizard) getWizard()); + ((BMotionAbstractWizard) getWizard()).getName()); TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE); @@ -222,7 +223,7 @@ public class WizardObserverListenOperationByPredicate extends ObserverWizard { @Override protected boolean canEdit(Object element) { - return WizardObserverUtil.isEditElement(getViewer()); + return BMotionWizardUtil.isEditElement(getViewer()); } @Override diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSetAttribute.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSetAttribute.java index 67cf0e0d8415260bf5bba7b79081fa38144805ae..737d8d6632968599bcb59ec2d4bf874ba9891e15 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSetAttribute.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSetAttribute.java @@ -48,6 +48,7 @@ import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Display; import de.be4.classicalb.core.parser.BParser; +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.EditorImageRegistry; import de.bmotionstudio.gef.editor.attribute.AbstractAttribute; @@ -61,7 +62,7 @@ import de.bmotionstudio.gef.editor.observer.ObserverWizard; import de.bmotionstudio.gef.editor.observer.SetAttribute; import de.bmotionstudio.gef.editor.observer.SetAttributeObject; import de.bmotionstudio.gef.editor.property.CheckboxCellEditorHelper; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class WizardObserverSetAttribute extends ObserverWizard { @@ -90,9 +91,9 @@ public class WizardObserverSetAttribute extends ObserverWizard { Composite container = new Composite(parent, SWT.NONE); container.setLayout(gl); - tableViewer = WizardObserverUtil.createObserverWizardTableViewer( + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( container, SetAttributeObject.class, - (ObserverWizard) getWizard()); + ((BMotionAbstractWizard) getWizard()).getName()); tableViewer .addSelectionChangedListener(new ISelectionChangedListener() { @@ -216,7 +217,7 @@ public class WizardObserverSetAttribute extends ObserverWizard { @Override protected boolean canEdit(Object element) { - return WizardObserverUtil.isEditElement(getViewer()); + return BMotionWizardUtil.isEditElement(getViewer()); } @Override diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSimpleValueDisplay.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSimpleValueDisplay.java index 25c9eeea409159ca248eb48c4c0261ab196873e3..f8a7040057b65872931d09c65190837f27bd4c36 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSimpleValueDisplay.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSimpleValueDisplay.java @@ -1,142 +1,142 @@ -/** - * (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.bmotionstudio.gef.editor.observer.wizard; - -import org.eclipse.core.databinding.DataBindingContext; -import org.eclipse.core.databinding.beans.BeansObservables; -import org.eclipse.jface.databinding.swt.SWTObservables; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.jface.wizard.WizardPage; -import org.eclipse.swt.SWT; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Label; -import org.eclipse.swt.widgets.Text; - -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.observer.Observer; -import de.bmotionstudio.gef.editor.observer.ObserverWizard; -import de.bmotionstudio.gef.editor.observer.SimpleValueDisplay; - -public class WizardObserverSimpleValueDisplay extends ObserverWizard { - - private class ObserverSimpleValueDisplayPage extends WizardPage { - - private Text txtReplacementString; - private Text txtExpression; - private Text txtPredicate; - - public Text getTxtExpression() { - return txtExpression; - } - - protected ObserverSimpleValueDisplayPage(final String pageName) { - super(pageName); - } - - public void createControl(final Composite parent) { - - final DataBindingContext dbc = new DataBindingContext(); - - Composite container = new Composite(parent, SWT.NONE); - - container.setLayoutData(new GridData(GridData.FILL_BOTH)); - container.setLayout(new GridLayout(2, false)); - - Label lb = new Label(container, SWT.NONE); - lb.setText("Predicate:"); - - txtPredicate = new Text(container, SWT.BORDER); - txtPredicate.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); - txtPredicate.setFont(new Font(Display.getDefault(), new FontData( - "Arial", 10, SWT.NONE))); - - lb = new Label(container, SWT.NONE); - lb.setText("Expression:"); - lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); - - txtExpression = new Text(container, SWT.BORDER | SWT.MULTI - | SWT.WRAP); - txtExpression.setLayoutData(new GridData(GridData.FILL_BOTH)); - // txtExpression.setFont(JFaceResources.getFontRegistry().get( - // BMotionStudioConstants.RODIN_FONT_KEY)); - - lb = new Label(container, SWT.NONE); - lb.setText("Replacement String:"); - - txtReplacementString = new Text(container, SWT.BORDER); - txtReplacementString.setLayoutData(new GridData( - GridData.FILL_HORIZONTAL)); - txtReplacementString.setFont(new Font(Display.getDefault(), - new FontData("Arial", 10, SWT.NONE))); - - initBindings(dbc); - - setControl(container); - - } - - private void initBindings(DataBindingContext dbc) { - - dbc.bindValue(SWTObservables.observeText(txtPredicate, SWT.Modify), - BeansObservables.observeValue( - (SimpleValueDisplay) getObserver(), "predicate")); - - dbc.bindValue( - SWTObservables.observeText(txtExpression, SWT.Modify), - BeansObservables.observeValue( - (SimpleValueDisplay) getObserver(), "eval")); - - dbc.bindValue(SWTObservables.observeText(txtReplacementString, - SWT.Modify), BeansObservables.observeValue( - (SimpleValueDisplay) getObserver(), "replacementString")); - - } - - } - - public WizardObserverSimpleValueDisplay(BControl bcontrol, - Observer bobserver) { - super(bcontrol, bobserver); - addPage(new ObserverSimpleValueDisplayPage( - "ObserverSimpleValueDisplayPage")); - } - - @Override - protected Boolean prepareToFinish() { - - ObserverSimpleValueDisplayPage page = (ObserverSimpleValueDisplayPage) getPage("ObserverSimpleValueDisplayPage"); - - String errorStr = ""; - - if (page.getTxtExpression().getText().length() == 0) - errorStr += "Please enter an expression.\n"; - - if (page.getErrorMessage() != null) - errorStr += "Please check the syntax/parser error.\n"; - - if (errorStr.length() > 0) { - MessageDialog.openError(Display.getDefault().getActiveShell(), - "An Error occured", errorStr); - return false; - } - - return true; - - } - - @Override - public Point getSize() { - return new Point(600, 500); - } - -} +/** + * (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.bmotionstudio.gef.editor.observer.wizard; + +import org.eclipse.core.databinding.DataBindingContext; +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.jface.databinding.swt.SWTObservables; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Text; + +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.observer.Observer; +import de.bmotionstudio.gef.editor.observer.ObserverWizard; +import de.bmotionstudio.gef.editor.observer.SimpleValueDisplay; + +public class WizardObserverSimpleValueDisplay extends ObserverWizard { + + private class ObserverSimpleValueDisplayPage extends WizardPage { + + private Text txtReplacementString; + private Text txtExpression; + private Text txtPredicate; + + public Text getTxtExpression() { + return txtExpression; + } + + protected ObserverSimpleValueDisplayPage(final String pageName) { + super(pageName); + } + + public void createControl(final Composite parent) { + + final DataBindingContext dbc = new DataBindingContext(); + + Composite container = new Composite(parent, SWT.NONE); + + container.setLayoutData(new GridData(GridData.FILL_BOTH)); + container.setLayout(new GridLayout(2, false)); + + Label lb = new Label(container, SWT.NONE); + lb.setText("Predicate:"); + + txtPredicate = new Text(container, SWT.BORDER); + txtPredicate.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); + txtPredicate.setFont(new Font(Display.getDefault(), new FontData( + "Arial", 10, SWT.NONE))); + + lb = new Label(container, SWT.NONE); + lb.setText("Expression:"); + lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); + + txtExpression = new Text(container, SWT.BORDER | SWT.MULTI + | SWT.WRAP); + txtExpression.setLayoutData(new GridData(GridData.FILL_BOTH)); + // txtExpression.setFont(JFaceResources.getFontRegistry().get( + // BMotionStudioConstants.RODIN_FONT_KEY)); + + lb = new Label(container, SWT.NONE); + lb.setText("Replacement String:"); + + txtReplacementString = new Text(container, SWT.BORDER); + txtReplacementString.setLayoutData(new GridData( + GridData.FILL_HORIZONTAL)); + txtReplacementString.setFont(new Font(Display.getDefault(), + new FontData("Arial", 10, SWT.NONE))); + + initBindings(dbc); + + setControl(container); + + } + + private void initBindings(DataBindingContext dbc) { + + dbc.bindValue(SWTObservables.observeText(txtPredicate, SWT.Modify), + BeansObservables.observeValue( + (SimpleValueDisplay) getObserver(), "predicate")); + + dbc.bindValue( + SWTObservables.observeText(txtExpression, SWT.Modify), + BeansObservables.observeValue( + (SimpleValueDisplay) getObserver(), "eval")); + + dbc.bindValue(SWTObservables.observeText(txtReplacementString, + SWT.Modify), BeansObservables.observeValue( + (SimpleValueDisplay) getObserver(), "replacementString")); + + } + + } + + public WizardObserverSimpleValueDisplay(BControl bcontrol, + Observer bobserver) { + super(bcontrol, bobserver); + addPage(new ObserverSimpleValueDisplayPage( + "ObserverSimpleValueDisplayPage")); + } + + @Override + protected Boolean prepareToFinish() { + + ObserverSimpleValueDisplayPage page = (ObserverSimpleValueDisplayPage) getPage("ObserverSimpleValueDisplayPage"); + + String errorStr = ""; + + if (page.getTxtExpression().getText().length() == 0) + errorStr += "Please enter an expression.\n"; + + if (page.getErrorMessage() != null) + errorStr += "Please check the syntax/parser error.\n"; + + if (errorStr.length() > 0) { + MessageDialog.openError(Display.getDefault().getActiveShell(), + "An Error occured", errorStr); + return false; + } + + return true; + + } + + @Override + public Point getSize() { + return new Point(600, 500); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchCoordinates.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchCoordinates.java index b5f0ddce18b852b4de05161a07b19ac4ca91be7d..cbc251e3eeb3d7dc09526acd3007f377865e0aa7 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchCoordinates.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchCoordinates.java @@ -42,6 +42,7 @@ import org.eclipse.swt.widgets.Display; import de.be4.classicalb.core.parser.BParser; import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.EditorImageRegistry; import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; @@ -53,7 +54,7 @@ import de.bmotionstudio.gef.editor.observer.ObserverWizard; import de.bmotionstudio.gef.editor.observer.SwitchCoordinates; import de.bmotionstudio.gef.editor.observer.ToggleObjectCoordinates; import de.bmotionstudio.gef.editor.property.CheckboxCellEditorHelper; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class WizardObserverSwitchCoordinates extends ObserverWizard { @@ -72,9 +73,9 @@ public class WizardObserverSwitchCoordinates extends ObserverWizard { Composite container = new Composite(parent, SWT.NONE); container.setLayout(new GridLayout(1, true)); - tableViewer = WizardObserverUtil.createObserverWizardTableViewer( + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( container, ToggleObjectCoordinates.class, - (ObserverWizard) getWizard()); + ((BMotionAbstractWizard) getWizard()).getName()); tableViewer .addSelectionChangedListener(new ISelectionChangedListener() { diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchImage.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchImage.java index 169266c1efe1e2cf25d81988369e5c3b5afdb56e..b351ab0855b25b5cba5e4d2b55594aab52e411ac 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchImage.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/observer/wizard/WizardObserverSwitchImage.java @@ -39,6 +39,7 @@ import org.eclipse.swt.widgets.Display; import de.be4.classicalb.core.parser.BParser; import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.EditorImageRegistry; import de.bmotionstudio.gef.editor.edit.AttributeExpressionEdittingSupport; @@ -51,7 +52,7 @@ import de.bmotionstudio.gef.editor.observer.ObserverWizard; import de.bmotionstudio.gef.editor.observer.SwitchImage; import de.bmotionstudio.gef.editor.observer.ToggleObjectImage; import de.bmotionstudio.gef.editor.property.CheckboxCellEditorHelper; -import de.bmotionstudio.gef.editor.util.WizardObserverUtil; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; public class WizardObserverSwitchImage extends ObserverWizard { @@ -70,9 +71,9 @@ public class WizardObserverSwitchImage extends ObserverWizard { Composite container = new Composite(parent, SWT.NONE); container.setLayout(new GridLayout(1, true)); - tableViewer = WizardObserverUtil.createObserverWizardTableViewer( + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( container, ToggleObjectImage.class, - (ObserverWizard) getWizard()); + ((BMotionAbstractWizard) getWizard()).getName()); tableViewer .addSelectionChangedListener(new ISelectionChangedListener() { diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppAbstractTreeEditPart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppAbstractTreeEditPart.java index d1a5aa44614294ac08b22607eacf2bda477b676d..598d5f6bef4f92f5d7c2d4c703bf311331ed999d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppAbstractTreeEditPart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppAbstractTreeEditPart.java @@ -1,58 +1,58 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeListener; - -import org.eclipse.gef.EditPolicy; -import org.eclipse.gef.Request; -import org.eclipse.gef.RequestConstants; -import org.eclipse.gef.editparts.AbstractTreeEditPart; -import org.eclipse.ui.IPageLayout; -import org.eclipse.ui.IWorkbenchPage; -import org.eclipse.ui.PartInitException; -import org.eclipse.ui.PlatformUI; - -import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; -import de.bmotionstudio.gef.editor.model.BControl; - -public abstract class AppAbstractTreeEditPart extends AbstractTreeEditPart - implements PropertyChangeListener { - - public void activate() { - if (!isActive()) { - super.activate(); - ((BControl) getModel()).addPropertyChangeListener(this); - } - } - - public void deactivate() { - if (isActive()) { - super.deactivate(); - ((BControl) getModel()).removePropertyChangeListener(this); - } - } - - @Override - public void performRequest(Request req) { - if (req.getType().equals(RequestConstants.REQ_OPEN)) { - try { - IWorkbenchPage page = PlatformUI.getWorkbench() - .getActiveWorkbenchWindow().getActivePage(); - page.showView(IPageLayout.ID_PROP_SHEET); - } catch (PartInitException e) { - e.printStackTrace(); - } - } - } - - @Override - protected void createEditPolicies() { - installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeListener; + +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.Request; +import org.eclipse.gef.RequestConstants; +import org.eclipse.gef.editparts.AbstractTreeEditPart; +import org.eclipse.ui.IPageLayout; +import org.eclipse.ui.IWorkbenchPage; +import org.eclipse.ui.PartInitException; +import org.eclipse.ui.PlatformUI; + +import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; +import de.bmotionstudio.gef.editor.model.BControl; + +public abstract class AppAbstractTreeEditPart extends AbstractTreeEditPart + implements PropertyChangeListener { + + public void activate() { + if (!isActive()) { + super.activate(); + ((BControl) getModel()).addPropertyChangeListener(this); + } + } + + public void deactivate() { + if (isActive()) { + super.deactivate(); + ((BControl) getModel()).removePropertyChangeListener(this); + } + } + + @Override + public void performRequest(Request req) { + if (req.getType().equals(RequestConstants.REQ_OPEN)) { + try { + IWorkbenchPage page = PlatformUI.getWorkbench() + .getActiveWorkbenchWindow().getActivePage(); + page.showView(IPageLayout.ID_PROP_SHEET); + } catch (PartInitException e) { + e.printStackTrace(); + } + } + } + + @Override + protected void createEditPolicies() { + installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppEditPartFactory.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppEditPartFactory.java index 392ad3670b169c3666385f3b91c512dfa0404ec8..93e767184f18e07a80fb64947372129e022cf25f 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppEditPartFactory.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppEditPartFactory.java @@ -1,49 +1,49 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import org.eclipse.core.runtime.CoreException; -import org.eclipse.gef.EditPart; -import org.eclipse.gef.EditPartFactory; -import org.eclipse.gef.editparts.AbstractGraphicalEditPart; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.IBControlService; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class AppEditPartFactory implements EditPartFactory { - - @Override - public EditPart createEditPart(EditPart context, Object model) { - - AbstractGraphicalEditPart part = null; - - BControl control = (BControl) model; - - if (control instanceof Visualization) { - part = new VisualizationPart(); - } else { - try { - IBControlService service = (IBControlService) BMotionEditorPlugin - .getControlServices().get(control.getType()) - .createExecutableExtension("service"); - part = service.createEditPart(); - } catch (CoreException e) { - e.printStackTrace(); - } - } - - if (part != null) - part.setModel(control); - - // TODO: check if part == null - return part; - - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.EditPartFactory; +import org.eclipse.gef.editparts.AbstractGraphicalEditPart; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.IBControlService; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class AppEditPartFactory implements EditPartFactory { + + @Override + public EditPart createEditPart(EditPart context, Object model) { + + AbstractGraphicalEditPart part = null; + + BControl control = (BControl) model; + + if (control instanceof Visualization) { + part = new VisualizationPart(); + } else { + try { + IBControlService service = (IBControlService) BMotionEditorPlugin + .getControlServices().get(control.getType()) + .createExecutableExtension("service"); + part = service.createEditPart(); + } catch (CoreException e) { + e.printStackTrace(); + } + } + + if (part != null) + part.setModel(control); + + // TODO: check if part == null + return part; + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppTreeEditPartFactory.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppTreeEditPartFactory.java index 4a0001172af51b81a6a6bcda1f2f7e5878d98fc4..42aa2bc89431930956047e78a6a921b167517199 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppTreeEditPartFactory.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/AppTreeEditPartFactory.java @@ -1,26 +1,26 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import org.eclipse.gef.EditPart; -import org.eclipse.gef.EditPartFactory; - -import de.bmotionstudio.gef.editor.model.BControl; - -public class AppTreeEditPartFactory implements EditPartFactory { - - public EditPart createEditPart(EditPart context, Object model) { - BControlTreeEditPart part = null; - if (model instanceof BControl) { - part = new BControlTreeEditPart(); - if (part != null) - part.setModel(model); - } - return part; - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import org.eclipse.gef.EditPart; +import org.eclipse.gef.EditPartFactory; + +import de.bmotionstudio.gef.editor.model.BControl; + +public class AppTreeEditPartFactory implements EditPartFactory { + + public EditPart createEditPart(EditPart context, Object model) { + BControlTreeEditPart part = null; + if (model instanceof BControl) { + part = new BControlTreeEditPart(); + if (part != null) + part.setModel(model); + } + return part; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BButtonPart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BButtonPart.java index e242ca8dc02bfff5fa940dba6389aa55ef1da197..9b8a4ab84fba92da177f7b4fec5002e82b208c26 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BButtonPart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BButtonPart.java @@ -1,86 +1,86 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; - -import org.eclipse.draw2d.IFigure; -import org.eclipse.gef.EditPolicy; -import org.eclipse.gef.Request; -import org.eclipse.gef.RequestConstants; -import org.eclipse.swt.graphics.RGB; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.edit.TextCellEditorLocator; -import de.bmotionstudio.gef.editor.edit.TextEditManager; -import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; -import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; -import de.bmotionstudio.gef.editor.editpolicy.CustomDirectEditPolicy; -import de.bmotionstudio.gef.editor.editpolicy.RenamePolicy; -import de.bmotionstudio.gef.editor.figure.ButtonFigure; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BButtonPart extends AppAbstractEditPart { - - @Override - public void refreshEditFigure(IFigure figure, BControl model, - PropertyChangeEvent evt) { - - Object value = evt.getNewValue(); - String aID = evt.getPropertyName(); - - if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT)) - ((ButtonFigure) figure).setText(value.toString()); - - if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) - ((ButtonFigure) figure).setBackgroundColor((RGB) value); - - if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT_COLOR)) - ((ButtonFigure) figure).setTextColor((RGB) value); - - if (aID.equals(AttributeConstants.ATTRIBUTE_ENABLED)) - ((ButtonFigure) figure).setBtEnabled(Boolean.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) - ((ButtonFigure) figure).setVisible(Boolean.valueOf(value.toString())); - - } - - @Override - protected IFigure createEditFigure() { - IFigure figure = new ButtonFigure(); - return figure; - } - - private void performDirectEdit() { - new TextEditManager(this, new TextCellEditorLocator( - (IFigure) getFigure())).show(); - } - - @Override - public void performRequest(Request request) { - super.performRequest(request); - if (request.getType() == RequestConstants.REQ_DIRECT_EDIT - && !isRunning()) - performDirectEdit(); - } - - @Override - protected void prepareEditPolicies() { - installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); - installEditPolicy(EditPolicy.NODE_ROLE, new RenamePolicy()); - installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, - new CustomDirectEditPolicy()); - installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, - new BMotionNodeEditPolicy()); - } - - @Override - protected void prepareRunPolicies() { - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.Request; +import org.eclipse.gef.RequestConstants; +import org.eclipse.swt.graphics.RGB; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.edit.TextCellEditorLocator; +import de.bmotionstudio.gef.editor.edit.TextEditManager; +import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; +import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; +import de.bmotionstudio.gef.editor.editpolicy.CustomDirectEditPolicy; +import de.bmotionstudio.gef.editor.editpolicy.RenamePolicy; +import de.bmotionstudio.gef.editor.figure.ButtonFigure; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BButtonPart extends AppAbstractEditPart { + + @Override + public void refreshEditFigure(IFigure figure, BControl model, + PropertyChangeEvent evt) { + + Object value = evt.getNewValue(); + String aID = evt.getPropertyName(); + + if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT)) + ((ButtonFigure) figure).setText(value.toString()); + + if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) + ((ButtonFigure) figure).setBackgroundColor((RGB) value); + + if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT_COLOR)) + ((ButtonFigure) figure).setTextColor((RGB) value); + + if (aID.equals(AttributeConstants.ATTRIBUTE_ENABLED)) + ((ButtonFigure) figure).setBtEnabled(Boolean.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) + ((ButtonFigure) figure).setVisible(Boolean.valueOf(value.toString())); + + } + + @Override + protected IFigure createEditFigure() { + IFigure figure = new ButtonFigure(); + return figure; + } + + private void performDirectEdit() { + new TextEditManager(this, new TextCellEditorLocator( + (IFigure) getFigure())).show(); + } + + @Override + public void performRequest(Request request) { + super.performRequest(request); + if (request.getType() == RequestConstants.REQ_DIRECT_EDIT + && !isRunning()) + performDirectEdit(); + } + + @Override + protected void prepareEditPolicies() { + installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); + installEditPolicy(EditPolicy.NODE_ROLE, new RenamePolicy()); + installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, + new CustomDirectEditPolicy()); + installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, + new BMotionNodeEditPolicy()); + } + + @Override + protected void prepareRunPolicies() { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCanisterPart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCanisterPart.java index 51cacf5bbc729897b50d93ea37d97da0e3dc1960..ca67098a873d9fabdd7c26867b887401834853d1 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCanisterPart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCanisterPart.java @@ -1,60 +1,60 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; - -import org.eclipse.draw2d.IFigure; -import org.eclipse.swt.graphics.RGB; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.figure.CanisterFigure; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BCanisterPart extends AppAbstractEditPart { - - @Override - protected IFigure createEditFigure() { - IFigure figure = new CanisterFigure(); - return figure; - } - - @Override - public void refreshEditFigure(IFigure figure, BControl model, - PropertyChangeEvent evt) { - ((CanisterFigure) figure).setAlpha(Integer.valueOf(model - .getAttributeValue(AttributeConstants.ATTRIBUTE_ALPHA) - .toString())); - ((CanisterFigure) figure).setFillColor((RGB) model - .getAttributeValue(AttributeConstants.ATTRIBUTE_FILL_COLOR)); - ((CanisterFigure) figure).setFillHeight(Integer.valueOf(model - .getAttributeValue(AttributeConstants.ATTRIBUTE_FILL_HEIGHT) - .toString())); - ((CanisterFigure) figure).setMaxPos(Integer.valueOf(model - .getAttributeValue(AttributeConstants.ATTRIBUTE_MEASURE_MAXPOS) - .toString())); - ((CanisterFigure) figure).setInterval(Integer.valueOf(model - .getAttributeValue( - AttributeConstants.ATTRIBUTE_MEASURE_INTERVAL) - .toString())); - ((CanisterFigure) figure).setMeasure(Boolean.valueOf(model - .getAttributeValue(AttributeConstants.ATTRIBUTE_SHOWS_MEASURE) - .toString())); - ((CanisterFigure) figure) - .setBackgroundColor((RGB) model - .getAttributeValue(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)); - } - - @Override - protected void prepareEditPolicies() { - } - - @Override - protected void prepareRunPolicies() { - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.swt.graphics.RGB; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.figure.CanisterFigure; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BCanisterPart extends AppAbstractEditPart { + + @Override + protected IFigure createEditFigure() { + IFigure figure = new CanisterFigure(); + return figure; + } + + @Override + public void refreshEditFigure(IFigure figure, BControl model, + PropertyChangeEvent evt) { + ((CanisterFigure) figure).setAlpha(Integer.valueOf(model + .getAttributeValue(AttributeConstants.ATTRIBUTE_ALPHA) + .toString())); + ((CanisterFigure) figure).setFillColor((RGB) model + .getAttributeValue(AttributeConstants.ATTRIBUTE_FILL_COLOR)); + ((CanisterFigure) figure).setFillHeight(Integer.valueOf(model + .getAttributeValue(AttributeConstants.ATTRIBUTE_FILL_HEIGHT) + .toString())); + ((CanisterFigure) figure).setMaxPos(Integer.valueOf(model + .getAttributeValue(AttributeConstants.ATTRIBUTE_MEASURE_MAXPOS) + .toString())); + ((CanisterFigure) figure).setInterval(Integer.valueOf(model + .getAttributeValue( + AttributeConstants.ATTRIBUTE_MEASURE_INTERVAL) + .toString())); + ((CanisterFigure) figure).setMeasure(Boolean.valueOf(model + .getAttributeValue(AttributeConstants.ATTRIBUTE_SHOWS_MEASURE) + .toString())); + ((CanisterFigure) figure) + .setBackgroundColor((RGB) model + .getAttributeValue(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)); + } + + @Override + protected void prepareEditPolicies() { + } + + @Override + protected void prepareRunPolicies() { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCompositePart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCompositePart.java index 9774726354aefa07bf454f483e16b8dfaf89923e..1e363ea954bbba36b1c44bdcbfcda3c26a06294d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCompositePart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BCompositePart.java @@ -1,147 +1,147 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; -import java.io.File; -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.core.resources.IFile; -import org.eclipse.draw2d.IFigure; -import org.eclipse.gef.CompoundSnapToHelper; -import org.eclipse.gef.EditPolicy; -import org.eclipse.gef.SnapToGeometry; -import org.eclipse.gef.SnapToGrid; -import org.eclipse.gef.SnapToGuides; -import org.eclipse.gef.SnapToHelper; -import org.eclipse.gef.editpolicies.SnapFeedbackPolicy; -import org.eclipse.gef.rulers.RulerProvider; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; -import de.bmotionstudio.gef.editor.editpolicy.AppEditLayoutPolicy; -import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; -import de.bmotionstudio.gef.editor.editpolicy.ChangeAttributePolicy; -import de.bmotionstudio.gef.editor.figure.CompositeFigure; -import de.bmotionstudio.gef.editor.library.AbstractLibraryCommand; -import de.bmotionstudio.gef.editor.library.AttributeRequest; -import de.bmotionstudio.gef.editor.library.LibraryImageCommand; -import de.bmotionstudio.gef.editor.library.LibraryVariableCommand; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BCompositePart extends AppAbstractEditPart { - - @Override - protected IFigure createEditFigure() { - IFigure figure = new CompositeFigure(); - return figure; - } - - @Override - public void refreshEditFigure(IFigure figure, BControl model, - PropertyChangeEvent evt) { - - Object value = evt.getNewValue(); - String aID = evt.getPropertyName(); - - if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) - ((CompositeFigure) figure).setBackgroundColor((RGB) value); - - // if (aID.equals(AttributeConstants.ATTRIBUTE_ALPHA)) - // ((BComposite) figure).setAlpha(Integer.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_IMAGE)) { - if (value != null) { - String imgPath = value.toString(); - if (imgPath.length() > 0) { - IFile pFile = model.getVisualization().getProjectFile(); - String myPath = (pFile.getProject().getLocation() - + "/images/" + imgPath).replace("file:", ""); - if (new File(myPath).exists()) { - ((CompositeFigure) figure).setImage(new Image(Display - .getDefault(), myPath)); - } - } - } - - } - - if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) - ((CompositeFigure) figure).setVisible(Boolean.valueOf(value - .toString())); - - } - - @Override - public List<BControl> getModelChildren() { - return ((BControl) getModel()).getChildrenArray(); - } - - @SuppressWarnings({ "unchecked", "rawtypes" }) - public Object getAdapter(Class adapter) { - if (adapter == SnapToHelper.class) { - List snapStrategies = new ArrayList(); - Boolean val = (Boolean) getViewer().getProperty( - RulerProvider.PROPERTY_RULER_VISIBILITY); - if (val != null && val.booleanValue()) - snapStrategies.add(new SnapToGuides(this)); - val = (Boolean) getViewer().getProperty( - SnapToGeometry.PROPERTY_SNAP_ENABLED); - if (val != null && val.booleanValue()) - snapStrategies.add(new SnapToGeometry(this)); - val = (Boolean) getViewer().getProperty( - SnapToGrid.PROPERTY_GRID_ENABLED); - if (val != null && val.booleanValue()) - snapStrategies.add(new SnapToGrid(this)); - - if (snapStrategies.size() == 0) - return null; - if (snapStrategies.size() == 1) - return snapStrategies.get(0); - - SnapToHelper ss[] = new SnapToHelper[snapStrategies.size()]; - for (int i = 0; i < snapStrategies.size(); i++) - ss[i] = (SnapToHelper) snapStrategies.get(i); - return new CompoundSnapToHelper(ss); - } - return super.getAdapter(adapter); - } - - @Override - public AbstractLibraryCommand getLibraryCommand(AttributeRequest request) { - AbstractLibraryCommand command = null; - if (request.getAttributeTransferObject().getLibraryObject().getType() - .equals("variable")) { - command = new LibraryVariableCommand(); - } else if (request.getAttributeTransferObject().getLibraryObject() - .getType().equals("image")) { - command = new LibraryImageCommand(); - } - return command; - } - - @Override - protected void prepareEditPolicies() { - installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); - installEditPolicy(EditPolicy.LAYOUT_ROLE, new AppEditLayoutPolicy()); - installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, null); - installEditPolicy(EditPolicy.CONTAINER_ROLE, new SnapFeedbackPolicy()); - installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, - new BMotionNodeEditPolicy()); - installEditPolicy(ChangeAttributePolicy.CHANGE_ATTRIBUTE_POLICY, - new ChangeAttributePolicy()); - } - - @Override - protected void prepareRunPolicies() { - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.resources.IFile; +import org.eclipse.draw2d.IFigure; +import org.eclipse.gef.CompoundSnapToHelper; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.SnapToGeometry; +import org.eclipse.gef.SnapToGrid; +import org.eclipse.gef.SnapToGuides; +import org.eclipse.gef.SnapToHelper; +import org.eclipse.gef.editpolicies.SnapFeedbackPolicy; +import org.eclipse.gef.rulers.RulerProvider; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; +import de.bmotionstudio.gef.editor.editpolicy.AppEditLayoutPolicy; +import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; +import de.bmotionstudio.gef.editor.editpolicy.ChangeAttributePolicy; +import de.bmotionstudio.gef.editor.figure.CompositeFigure; +import de.bmotionstudio.gef.editor.library.AbstractLibraryCommand; +import de.bmotionstudio.gef.editor.library.AttributeRequest; +import de.bmotionstudio.gef.editor.library.LibraryImageCommand; +import de.bmotionstudio.gef.editor.library.LibraryVariableCommand; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BCompositePart extends AppAbstractEditPart { + + @Override + protected IFigure createEditFigure() { + IFigure figure = new CompositeFigure(); + return figure; + } + + @Override + public void refreshEditFigure(IFigure figure, BControl model, + PropertyChangeEvent evt) { + + Object value = evt.getNewValue(); + String aID = evt.getPropertyName(); + + if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) + ((CompositeFigure) figure).setBackgroundColor((RGB) value); + + // if (aID.equals(AttributeConstants.ATTRIBUTE_ALPHA)) + // ((BComposite) figure).setAlpha(Integer.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_IMAGE)) { + if (value != null) { + String imgPath = value.toString(); + if (imgPath.length() > 0) { + IFile pFile = model.getVisualization().getProjectFile(); + String myPath = (pFile.getProject().getLocation() + + "/images/" + imgPath).replace("file:", ""); + if (new File(myPath).exists()) { + ((CompositeFigure) figure).setImage(new Image(Display + .getDefault(), myPath)); + } + } + } + + } + + if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) + ((CompositeFigure) figure).setVisible(Boolean.valueOf(value + .toString())); + + } + + @Override + public List<BControl> getModelChildren() { + return ((BControl) getModel()).getChildrenArray(); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + public Object getAdapter(Class adapter) { + if (adapter == SnapToHelper.class) { + List snapStrategies = new ArrayList(); + Boolean val = (Boolean) getViewer().getProperty( + RulerProvider.PROPERTY_RULER_VISIBILITY); + if (val != null && val.booleanValue()) + snapStrategies.add(new SnapToGuides(this)); + val = (Boolean) getViewer().getProperty( + SnapToGeometry.PROPERTY_SNAP_ENABLED); + if (val != null && val.booleanValue()) + snapStrategies.add(new SnapToGeometry(this)); + val = (Boolean) getViewer().getProperty( + SnapToGrid.PROPERTY_GRID_ENABLED); + if (val != null && val.booleanValue()) + snapStrategies.add(new SnapToGrid(this)); + + if (snapStrategies.size() == 0) + return null; + if (snapStrategies.size() == 1) + return snapStrategies.get(0); + + SnapToHelper ss[] = new SnapToHelper[snapStrategies.size()]; + for (int i = 0; i < snapStrategies.size(); i++) + ss[i] = (SnapToHelper) snapStrategies.get(i); + return new CompoundSnapToHelper(ss); + } + return super.getAdapter(adapter); + } + + @Override + public AbstractLibraryCommand getLibraryCommand(AttributeRequest request) { + AbstractLibraryCommand command = null; + if (request.getAttributeTransferObject().getLibraryObject().getType() + .equals("variable")) { + command = new LibraryVariableCommand(); + } else if (request.getAttributeTransferObject().getLibraryObject() + .getType().equals("image")) { + command = new LibraryImageCommand(); + } + return command; + } + + @Override + protected void prepareEditPolicies() { + installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); + installEditPolicy(EditPolicy.LAYOUT_ROLE, new AppEditLayoutPolicy()); + installEditPolicy(EditPolicy.SELECTION_FEEDBACK_ROLE, null); + installEditPolicy(EditPolicy.CONTAINER_ROLE, new SnapFeedbackPolicy()); + installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, + new BMotionNodeEditPolicy()); + installEditPolicy(ChangeAttributePolicy.CHANGE_ATTRIBUTE_POLICY, + new ChangeAttributePolicy()); + } + + @Override + protected void prepareRunPolicies() { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BControlTreeEditPart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BControlTreeEditPart.java index fd40016a6ab3a0a302bcff1cb29efdc381db59b5..2daad4048612c7d6328f84acf178e3e5e0f9d041 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BControlTreeEditPart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BControlTreeEditPart.java @@ -1,65 +1,65 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.BMotionStudioImage; -import de.bmotionstudio.gef.editor.model.BConnection; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.Visualization; - -public class BControlTreeEditPart extends AppAbstractTreeEditPart { - - @Override - protected List<BControl> getModelChildren() { - Set<BControl> toShowElements = new HashSet<BControl>(); - for (BControl control : ((BControl) getModel()).getChildrenArray()) { - if (control.showInOutlineView()) - toShowElements.add(control); - List<BConnection> sourceConnections = control - .getSourceConnections(); - for (BConnection con : sourceConnections) { - if (con.showInOutlineView()) - toShowElements.add(con); - } - List<BConnection> targetConnections = control - .getTargetConnections(); - for (BConnection con : targetConnections) { - if (con.showInOutlineView()) - toShowElements.add(con); - } - } - return new ArrayList<BControl>(toShowElements); - } - - public void propertyChange(final PropertyChangeEvent evt) { - if (evt.getPropertyName().equals(BControl.PROPERTY_ADD) - || evt.getPropertyName().equals(BControl.PROPERTY_REMOVE)) { - refreshChildren(); - } - if (evt.getPropertyName().equals(AttributeConstants.ATTRIBUTE_ID)) - refreshVisuals(); - } - - @Override - public void refreshVisuals() { - BControl bcontrol = (BControl) getModel(); - if (!(bcontrol instanceof Visualization)) { - setWidgetText(bcontrol.getAttributeValue( - AttributeConstants.ATTRIBUTE_ID).toString()); - setWidgetImage(BMotionStudioImage.getBControlImage(bcontrol - .getType())); - } - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.BMotionStudioImage; +import de.bmotionstudio.gef.editor.model.BConnection; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.model.Visualization; + +public class BControlTreeEditPart extends AppAbstractTreeEditPart { + + @Override + protected List<BControl> getModelChildren() { + Set<BControl> toShowElements = new HashSet<BControl>(); + for (BControl control : ((BControl) getModel()).getChildrenArray()) { + if (control.showInOutlineView()) + toShowElements.add(control); + List<BConnection> sourceConnections = control + .getSourceConnections(); + for (BConnection con : sourceConnections) { + if (con.showInOutlineView()) + toShowElements.add(con); + } + List<BConnection> targetConnections = control + .getTargetConnections(); + for (BConnection con : targetConnections) { + if (con.showInOutlineView()) + toShowElements.add(con); + } + } + return new ArrayList<BControl>(toShowElements); + } + + public void propertyChange(final PropertyChangeEvent evt) { + if (evt.getPropertyName().equals(BControl.PROPERTY_ADD) + || evt.getPropertyName().equals(BControl.PROPERTY_REMOVE)) { + refreshChildren(); + } + if (evt.getPropertyName().equals(AttributeConstants.ATTRIBUTE_ID)) + refreshVisuals(); + } + + @Override + public void refreshVisuals() { + BControl bcontrol = (BControl) getModel(); + if (!(bcontrol instanceof Visualization)) { + setWidgetText(bcontrol.getAttributeValue( + AttributeConstants.ATTRIBUTE_ID).toString()); + setWidgetImage(BMotionStudioImage.getBControlImage(bcontrol + .getType())); + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BShapePart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BShapePart.java index 247e9c658eda973343d6627c8a5763525645a401..1ffe72f87ae2e019e9b5e5fb9265e615c88b5596 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BShapePart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BShapePart.java @@ -1,129 +1,129 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; -import java.io.File; - -import org.eclipse.core.resources.IFile; -import org.eclipse.draw2d.IFigure; -import org.eclipse.gef.EditPolicy; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; -import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; -import de.bmotionstudio.gef.editor.figure.ShapeFigure; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BShapePart extends AppAbstractEditPart { - - @Override - public void refreshEditFigure(IFigure figure, BControl model, - PropertyChangeEvent evt) { - - Object value = evt.getNewValue(); - String aID = evt.getPropertyName(); - - if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) - ((ShapeFigure) figure).setBackgroundColor((RGB) value); - - if (aID.equals(AttributeConstants.ATTRIBUTE_FOREGROUND_COLOR)) - ((ShapeFigure) figure).setForegroundColor((RGB) value); - - if (aID.equals(AttributeConstants.ATTRIBUTE_ALPHA)) - ((ShapeFigure) figure).setAlpha(Integer.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_OUTLINEALPHA)) - ((ShapeFigure) figure) - .setOutlineAlpha(Integer.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) - ((ShapeFigure) figure).setVisible(Boolean.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_SHAPE)) - ((ShapeFigure) figure).setShape(Integer.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_ORIENTATION)) - ((ShapeFigure) figure).setOrientation(Integer.valueOf(value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_FILLTYPE)) - ((ShapeFigure) figure).setFillType(Integer.valueOf(value.toString())); - - // /** North */ - // int NORTH = 1; - // /** South */ - // int SOUTH = 4; - // /** West */ - // int WEST = 8; - // /** East */ - // int EAST = 16; - - if (aID.equals(AttributeConstants.ATTRIBUTE_DIRECTION)) { - - int direction = Integer.valueOf(value.toString()); - int fval = 1; - - switch (direction) { - case 0: - fval = 1; - break; - case 1: - fval = 4; - break; - case 2: - fval = 8; - break; - case 3: - fval = 16; - break; - default: - break; - } - - ((ShapeFigure) figure).setDirection(fval); - - } - - if (aID.equals(AttributeConstants.ATTRIBUTE_IMAGE)) { - Image img = null; - if (value != null) { - String imgPath = value.toString(); - if (imgPath.length() > 0) { - IFile pFile = model.getVisualization().getProjectFile(); - String myPath = (pFile.getProject().getLocation() - + "/images/" + imgPath).replace("file:", ""); - if (new File(myPath).exists()) { - img = new Image(Display.getDefault(), myPath); - } - } - } - ((ShapeFigure) figure).setImage(img); - } - - } - - @Override - protected IFigure createEditFigure() { - IFigure figure = new ShapeFigure(); - return figure; - } - - @Override - protected void prepareEditPolicies() { - installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); - installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, - new BMotionNodeEditPolicy()); - } - - @Override - protected void prepareRunPolicies() { - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; +import java.io.File; + +import org.eclipse.core.resources.IFile; +import org.eclipse.draw2d.IFigure; +import org.eclipse.gef.EditPolicy; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; +import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; +import de.bmotionstudio.gef.editor.figure.ShapeFigure; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BShapePart extends AppAbstractEditPart { + + @Override + public void refreshEditFigure(IFigure figure, BControl model, + PropertyChangeEvent evt) { + + Object value = evt.getNewValue(); + String aID = evt.getPropertyName(); + + if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) + ((ShapeFigure) figure).setBackgroundColor((RGB) value); + + if (aID.equals(AttributeConstants.ATTRIBUTE_FOREGROUND_COLOR)) + ((ShapeFigure) figure).setForegroundColor((RGB) value); + + if (aID.equals(AttributeConstants.ATTRIBUTE_ALPHA)) + ((ShapeFigure) figure).setAlpha(Integer.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_OUTLINEALPHA)) + ((ShapeFigure) figure) + .setOutlineAlpha(Integer.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) + ((ShapeFigure) figure).setVisible(Boolean.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_SHAPE)) + ((ShapeFigure) figure).setShape(Integer.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_ORIENTATION)) + ((ShapeFigure) figure).setOrientation(Integer.valueOf(value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_FILLTYPE)) + ((ShapeFigure) figure).setFillType(Integer.valueOf(value.toString())); + + // /** North */ + // int NORTH = 1; + // /** South */ + // int SOUTH = 4; + // /** West */ + // int WEST = 8; + // /** East */ + // int EAST = 16; + + if (aID.equals(AttributeConstants.ATTRIBUTE_DIRECTION)) { + + int direction = Integer.valueOf(value.toString()); + int fval = 1; + + switch (direction) { + case 0: + fval = 1; + break; + case 1: + fval = 4; + break; + case 2: + fval = 8; + break; + case 3: + fval = 16; + break; + default: + break; + } + + ((ShapeFigure) figure).setDirection(fval); + + } + + if (aID.equals(AttributeConstants.ATTRIBUTE_IMAGE)) { + Image img = null; + if (value != null) { + String imgPath = value.toString(); + if (imgPath.length() > 0) { + IFile pFile = model.getVisualization().getProjectFile(); + String myPath = (pFile.getProject().getLocation() + + "/images/" + imgPath).replace("file:", ""); + if (new File(myPath).exists()) { + img = new Image(Display.getDefault(), myPath); + } + } + } + ((ShapeFigure) figure).setImage(img); + } + + } + + @Override + protected IFigure createEditFigure() { + IFigure figure = new ShapeFigure(); + return figure; + } + + @Override + protected void prepareEditPolicies() { + installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); + installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, + new BMotionNodeEditPolicy()); + } + + @Override + protected void prepareRunPolicies() { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BTextPart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BTextPart.java index eeead135623a30523879ed597afe3d8c3cb2627d..5de397b03f7d9a59b8da669bc3a0256c769d3ef6 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BTextPart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/BTextPart.java @@ -1,114 +1,114 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; - -import org.eclipse.draw2d.IFigure; -import org.eclipse.gef.EditPolicy; -import org.eclipse.gef.Request; -import org.eclipse.gef.RequestConstants; -import org.eclipse.swt.graphics.RGB; -import org.eclipse.swt.widgets.Display; - -import de.bmotionstudio.gef.editor.AttributeConstants; -import de.bmotionstudio.gef.editor.edit.TextCellEditorLocator; -import de.bmotionstudio.gef.editor.edit.TextEditManager; -import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; -import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; -import de.bmotionstudio.gef.editor.editpolicy.ChangeAttributePolicy; -import de.bmotionstudio.gef.editor.editpolicy.CustomDirectEditPolicy; -import de.bmotionstudio.gef.editor.editpolicy.RenamePolicy; -import de.bmotionstudio.gef.editor.figure.TextFigure; -import de.bmotionstudio.gef.editor.library.AbstractLibraryCommand; -import de.bmotionstudio.gef.editor.library.AttributeRequest; -import de.bmotionstudio.gef.editor.library.LibraryVariableCommand; -import de.bmotionstudio.gef.editor.model.BControl; - -public class BTextPart extends AppAbstractEditPart { - - @Override - public void refreshEditFigure(IFigure figure, BControl model, - PropertyChangeEvent evt) { - - Object value = evt.getNewValue(); - String aID = evt.getPropertyName(); - - if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT)) - ((TextFigure) figure).setText(value.toString()); - - if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) - ((TextFigure) figure) - .setBackgroundColor(new org.eclipse.swt.graphics.Color( - Display.getDefault(), (RGB) value)); - - if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT_COLOR)) - ((TextFigure) figure).setTextColor(((RGB) value)); - - if (aID.equals(AttributeConstants.ATTRIBUTE_FONT)) - ((TextFigure) figure).setFont((value.toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_VISIBLE)) - ((TextFigure) figure).setBackgroundVisible(Boolean.valueOf(value - .toString())); - - if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) - ((TextFigure) figure).setVisible(Boolean.valueOf(value.toString())); - - } - - @Override - protected IFigure createEditFigure() { - IFigure figure = new TextFigure(); - return figure; - } - - private void performDirectEdit() { - new TextEditManager(this, new TextCellEditorLocator( - (IFigure) getFigure())).show(); - } - - @Override - public void performRequest(Request request) { - super.performRequest(request); - if (request.getType() == RequestConstants.REQ_DIRECT_EDIT) - performDirectEdit(); - } - - // @Override - // public String getValueOfData() { - // return ((BControl) getModel()).getAttributeValue( - // AttributeConstants.ATTRIBUTE_CUSTOM).toString(); - // } - - @Override - public AbstractLibraryCommand getLibraryCommand(AttributeRequest request) { - AbstractLibraryCommand command = null; - if (request.getAttributeTransferObject().getLibraryObject().getType() - .equals("variable")) { - command = new LibraryVariableCommand(); - } - return command; - } - - @Override - protected void prepareEditPolicies() { - installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); - installEditPolicy(EditPolicy.NODE_ROLE, new RenamePolicy()); - installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, - new CustomDirectEditPolicy()); - installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, - new BMotionNodeEditPolicy()); - installEditPolicy(ChangeAttributePolicy.CHANGE_ATTRIBUTE_POLICY, - new ChangeAttributePolicy()); - } - - @Override - protected void prepareRunPolicies() { - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; + +import org.eclipse.draw2d.IFigure; +import org.eclipse.gef.EditPolicy; +import org.eclipse.gef.Request; +import org.eclipse.gef.RequestConstants; +import org.eclipse.swt.graphics.RGB; +import org.eclipse.swt.widgets.Display; + +import de.bmotionstudio.gef.editor.AttributeConstants; +import de.bmotionstudio.gef.editor.edit.TextCellEditorLocator; +import de.bmotionstudio.gef.editor.edit.TextEditManager; +import de.bmotionstudio.gef.editor.editpolicy.AppDeletePolicy; +import de.bmotionstudio.gef.editor.editpolicy.BMotionNodeEditPolicy; +import de.bmotionstudio.gef.editor.editpolicy.ChangeAttributePolicy; +import de.bmotionstudio.gef.editor.editpolicy.CustomDirectEditPolicy; +import de.bmotionstudio.gef.editor.editpolicy.RenamePolicy; +import de.bmotionstudio.gef.editor.figure.TextFigure; +import de.bmotionstudio.gef.editor.library.AbstractLibraryCommand; +import de.bmotionstudio.gef.editor.library.AttributeRequest; +import de.bmotionstudio.gef.editor.library.LibraryVariableCommand; +import de.bmotionstudio.gef.editor.model.BControl; + +public class BTextPart extends AppAbstractEditPart { + + @Override + public void refreshEditFigure(IFigure figure, BControl model, + PropertyChangeEvent evt) { + + Object value = evt.getNewValue(); + String aID = evt.getPropertyName(); + + if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT)) + ((TextFigure) figure).setText(value.toString()); + + if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_COLOR)) + ((TextFigure) figure) + .setBackgroundColor(new org.eclipse.swt.graphics.Color( + Display.getDefault(), (RGB) value)); + + if (aID.equals(AttributeConstants.ATTRIBUTE_TEXT_COLOR)) + ((TextFigure) figure).setTextColor(((RGB) value)); + + if (aID.equals(AttributeConstants.ATTRIBUTE_FONT)) + ((TextFigure) figure).setFont((value.toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_BACKGROUND_VISIBLE)) + ((TextFigure) figure).setBackgroundVisible(Boolean.valueOf(value + .toString())); + + if (aID.equals(AttributeConstants.ATTRIBUTE_VISIBLE)) + ((TextFigure) figure).setVisible(Boolean.valueOf(value.toString())); + + } + + @Override + protected IFigure createEditFigure() { + IFigure figure = new TextFigure(); + return figure; + } + + private void performDirectEdit() { + new TextEditManager(this, new TextCellEditorLocator( + (IFigure) getFigure())).show(); + } + + @Override + public void performRequest(Request request) { + super.performRequest(request); + if (request.getType() == RequestConstants.REQ_DIRECT_EDIT) + performDirectEdit(); + } + + // @Override + // public String getValueOfData() { + // return ((BControl) getModel()).getAttributeValue( + // AttributeConstants.ATTRIBUTE_CUSTOM).toString(); + // } + + @Override + public AbstractLibraryCommand getLibraryCommand(AttributeRequest request) { + AbstractLibraryCommand command = null; + if (request.getAttributeTransferObject().getLibraryObject().getType() + .equals("variable")) { + command = new LibraryVariableCommand(); + } + return command; + } + + @Override + protected void prepareEditPolicies() { + installEditPolicy(EditPolicy.COMPONENT_ROLE, new AppDeletePolicy()); + installEditPolicy(EditPolicy.NODE_ROLE, new RenamePolicy()); + installEditPolicy(EditPolicy.DIRECT_EDIT_ROLE, + new CustomDirectEditPolicy()); + installEditPolicy(EditPolicy.GRAPHICAL_NODE_ROLE, + new BMotionNodeEditPolicy()); + installEditPolicy(ChangeAttributePolicy.CHANGE_ATTRIBUTE_POLICY, + new ChangeAttributePolicy()); + } + + @Override + protected void prepareRunPolicies() { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/UnknownPart.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/UnknownPart.java index 4e2c15c13f0025e9d23598a4ffd37c1ac31a17ca..5b18e42c3141e42b02b961b8e7180e199242df9d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/UnknownPart.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/part/UnknownPart.java @@ -1,46 +1,46 @@ -/** - * (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.bmotionstudio.gef.editor.part; - -import java.beans.PropertyChangeEvent; - -import org.eclipse.draw2d.IFigure; - -import de.bmotionstudio.gef.editor.figure.UnknownBControl; -import de.bmotionstudio.gef.editor.model.BControl; - -public class UnknownPart extends AppAbstractEditPart { - - public static String ID = "de.bmotionstudio.gef.editor.unknown"; - - private String type; - - @Override - protected IFigure createEditFigure() { - IFigure figure = new UnknownBControl(); - return figure; - } - - @Override - public void refreshEditFigure(IFigure figure, BControl model, - PropertyChangeEvent evt) { - ((UnknownBControl) figure).setMessage(type); - } - - public void setType(String type) { - this.type = type; - } - - @Override - protected void prepareEditPolicies() { - } - - @Override - protected void prepareRunPolicies() { - } - -} +/** + * (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.bmotionstudio.gef.editor.part; + +import java.beans.PropertyChangeEvent; + +import org.eclipse.draw2d.IFigure; + +import de.bmotionstudio.gef.editor.figure.UnknownBControl; +import de.bmotionstudio.gef.editor.model.BControl; + +public class UnknownPart extends AppAbstractEditPart { + + public static String ID = "de.bmotionstudio.gef.editor.unknown"; + + private String type; + + @Override + protected IFigure createEditFigure() { + IFigure figure = new UnknownBControl(); + return figure; + } + + @Override + public void refreshEditFigure(IFigure figure, BControl model, + PropertyChangeEvent evt) { + ((UnknownBControl) figure).setMessage(type); + } + + public void setType(String type) { + this.type = type; + } + + @Override + protected void prepareEditPolicies() { + } + + @Override + protected void prepareRunPolicies() { + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/CheckboxPropertyDescriptor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/CheckboxPropertyDescriptor.java index defac1f00ea74370dad46c99c2c1b3f880679e89..ffd872fbadbb3954f49a798710bd5c45c36f78fe 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/CheckboxPropertyDescriptor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/CheckboxPropertyDescriptor.java @@ -1,55 +1,55 @@ -/** - * (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.bmotionstudio.gef.editor.property; - -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.jface.viewers.CheckboxCellEditor; -import org.eclipse.jface.viewers.LabelProvider; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -public class CheckboxPropertyDescriptor extends PropertyDescriptor { - /** - * @param id - * @param displayName - */ - public CheckboxPropertyDescriptor(Object id, String displayName) { - super(id, displayName); - init(); - } - - protected void init() { - setLabelProvider(new LabelProvider() { - @Override - public Image getImage(Object element) { - if (element instanceof Boolean) { - boolean b = (Boolean) element; - return CheckboxCellEditorHelper.getCellEditorImage(b); - } - return super.getImage(element); - } - - @Override - public String getText(Object element) { - return ""; //$NON-NLS-1$ - } - }); - } - - /* - * @see - * org.eclipse.ui.views.properties.IPropertyDescriptor#createPropertyEditor - * (org.eclipse.swt.widgets.Composite) - */ - @Override - public CellEditor createPropertyEditor(Composite parent) { - CellEditor editor = new CheckboxCellEditor(parent); - return editor; - } - -} +/** + * (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.bmotionstudio.gef.editor.property; + +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.CheckboxCellEditor; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +public class CheckboxPropertyDescriptor extends PropertyDescriptor { + /** + * @param id + * @param displayName + */ + public CheckboxPropertyDescriptor(Object id, String displayName) { + super(id, displayName); + init(); + } + + protected void init() { + setLabelProvider(new LabelProvider() { + @Override + public Image getImage(Object element) { + if (element instanceof Boolean) { + boolean b = (Boolean) element; + return CheckboxCellEditorHelper.getCellEditorImage(b); + } + return super.getImage(element); + } + + @Override + public String getText(Object element) { + return ""; //$NON-NLS-1$ + } + }); + } + + /* + * @see + * org.eclipse.ui.views.properties.IPropertyDescriptor#createPropertyEditor + * (org.eclipse.swt.widgets.Composite) + */ + @Override + public CellEditor createPropertyEditor(Composite parent) { + CellEditor editor = new CheckboxCellEditor(parent); + return editor; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontDialogCellEditor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontDialogCellEditor.java index 0bc590b12885319bd10f2ce6f627c27bc3625bb2..b9c6bfeb6f24bdee6a7bcd0f46062f2a6067de72 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontDialogCellEditor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontDialogCellEditor.java @@ -1,60 +1,60 @@ -/** - * (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) - * */ - -/******************************************************************************* - * 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 de.bmotionstudio.gef.editor.property; - -import org.eclipse.jface.viewers.DialogCellEditor; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.FontDialog; -import org.eclipse.ui.PlatformUI; - -public class FontDialogCellEditor extends DialogCellEditor { - - /** - * Creates a new Font dialog cell editor parented under the given control. - * The cell editor value is <code>null</code> initially, and has no - * validator. - * - * @param parent - * the parent control - */ - protected FontDialogCellEditor(Composite parent) { - super(parent); - } - - /** - * @see org.eclipse.jface.viewers.DialogCellEditor#openDialogBox(Control) - */ - protected Object openDialogBox(Control cellEditorWindow) { - FontDialog ftDialog = new FontDialog(PlatformUI.getWorkbench() - .getActiveWorkbenchWindow().getShell()); - - String value = (String) getValue(); - - if ((value != null) && (value.length() > 0)) { - ftDialog.setFontList(new FontData[] { new FontData(value) }); - } - FontData fData = ftDialog.open(); - - if (fData != null) { - value = fData.toString(); - } - return value; - } - -} +/** + * (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) + * */ + +/******************************************************************************* + * 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 de.bmotionstudio.gef.editor.property; + +import org.eclipse.jface.viewers.DialogCellEditor; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.FontDialog; +import org.eclipse.ui.PlatformUI; + +public class FontDialogCellEditor extends DialogCellEditor { + + /** + * Creates a new Font dialog cell editor parented under the given control. + * The cell editor value is <code>null</code> initially, and has no + * validator. + * + * @param parent + * the parent control + */ + protected FontDialogCellEditor(Composite parent) { + super(parent); + } + + /** + * @see org.eclipse.jface.viewers.DialogCellEditor#openDialogBox(Control) + */ + protected Object openDialogBox(Control cellEditorWindow) { + FontDialog ftDialog = new FontDialog(PlatformUI.getWorkbench() + .getActiveWorkbenchWindow().getShell()); + + String value = (String) getValue(); + + if ((value != null) && (value.length() > 0)) { + ftDialog.setFontList(new FontData[] { new FontData(value) }); + } + FontData fData = ftDialog.open(); + + if (fData != null) { + value = fData.toString(); + } + return value; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontPropertyDescriptor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontPropertyDescriptor.java index 74061a30c31126cb37c254dd1ee1adc9afe36b5a..bc4eb2213e317ebe3f2e651a157ee0122063e717 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontPropertyDescriptor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/FontPropertyDescriptor.java @@ -1,54 +1,54 @@ -/** - * (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) - * */ - -/******************************************************************************* - * 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 de.bmotionstudio.gef.editor.property; - -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.jface.viewers.LabelProvider; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.ui.views.properties.PropertyDescriptor; - -public class FontPropertyDescriptor extends PropertyDescriptor { - - /** - * Creates an property descriptor with the given id and display name. - * - * @param id - * the id of the property - * @param displayName - * the name to display for the property - */ - public FontPropertyDescriptor(Object id, String displayName) { - super(id, displayName); - setLabelProvider(new LabelProvider() { - @Override - public String getText(Object element) { - return super.getText(element); - } - }); - } - - /** - * @see org.eclipse.ui.views.properties.IPropertyDescriptor#createPropertyEditor(Composite) - */ - public CellEditor createPropertyEditor(Composite parent) { - CellEditor editor = new FontDialogCellEditor(parent); - if (getValidator() != null) - editor.setValidator(getValidator()); - return editor; - } - -} +/** + * (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) + * */ + +/******************************************************************************* + * 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 de.bmotionstudio.gef.editor.property; + +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.LabelProvider; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.ui.views.properties.PropertyDescriptor; + +public class FontPropertyDescriptor extends PropertyDescriptor { + + /** + * Creates an property descriptor with the given id and display name. + * + * @param id + * the id of the property + * @param displayName + * the name to display for the property + */ + public FontPropertyDescriptor(Object id, String displayName) { + super(id, displayName); + setLabelProvider(new LabelProvider() { + @Override + public String getText(Object element) { + return super.getText(element); + } + }); + } + + /** + * @see org.eclipse.ui.views.properties.IPropertyDescriptor#createPropertyEditor(Composite) + */ + public CellEditor createPropertyEditor(Composite parent) { + CellEditor editor = new FontDialogCellEditor(parent); + if (getValidator() != null) + editor.setValidator(getValidator()); + return editor; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialog.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialog.java index 09ed8db26d1af112aa1ffb118672b9e978a6bb03..5fc1c992937aaf8192ea2ab7e25e9a78b041af29 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialog.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialog.java @@ -1,242 +1,242 @@ -/** - * (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.bmotionstudio.gef.editor.property; - -import java.io.File; -import java.io.FilenameFilter; -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.core.databinding.observable.list.WritableList; -import org.eclipse.core.resources.IFile; -import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; -import org.eclipse.jface.dialogs.Dialog; -import org.eclipse.jface.viewers.CellLabelProvider; -import org.eclipse.jface.viewers.ISelectionChangedListener; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.SelectionChangedEvent; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.viewers.TableViewerColumn; -import org.eclipse.jface.viewers.ViewerCell; -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.PaintEvent; -import org.eclipse.swt.events.PaintListener; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.FillLayout; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Canvas; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; - -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.BMotionStudioImage; -import de.bmotionstudio.gef.editor.EditorImageRegistry; -import de.bmotionstudio.gef.editor.library.LibraryImageObject; -import de.bmotionstudio.gef.editor.library.LibraryObject; - -public class ImageDialog extends Dialog { - - private TableViewer tvLibrary; - private Image previewImage; - private Composite preContainer; - private Canvas previewCanvas; - private final ImageDialogCellEditor imageDialogCellEditor; - - protected ImageDialog(final Shell parentShell, - final ImageDialogCellEditor imageDialogCellEditor) { - super(parentShell); - this.imageDialogCellEditor = imageDialogCellEditor; - } - - @Override - protected Control createDialogArea(final Composite parent) { - - Composite container = (Composite) super.createDialogArea(parent); - - GridLayout gl = new GridLayout(1, true); - gl.horizontalSpacing = 0; - container.setLayout(gl); - - GridData gd = new GridData(GridData.FILL_BOTH); - gd.horizontalIndent = 0; - - preContainer = new Composite(container, SWT.NONE); - preContainer.setLayoutData(gd); - preContainer.setLayout(new FillLayout()); - - previewCanvas = new Canvas(preContainer, SWT.BORDER); - previewCanvas.addPaintListener(new PaintListener() { - public void paintControl(final PaintEvent e) { - if (previewImage == null) { - e.gc.drawString("No image selected ...", 0, 0); - } else { - e.gc.drawImage(previewImage, 0, 0); - } - } - }); - - final Composite libContainer = new Composite(container, SWT.NONE); - libContainer.setLayoutData(gd); - libContainer.setLayout(new FillLayout()); - - tvLibrary = new TableViewer(libContainer, SWT.FULL_SELECTION - | SWT.V_SCROLL); - tvLibrary.getTable().setLayoutData(gd); - tvLibrary.addSelectionChangedListener(new ISelectionChangedListener() { - - public void selectionChanged(final SelectionChangedEvent event) { - - IStructuredSelection selection = (IStructuredSelection) event - .getSelection(); - - LibraryObject obj = (LibraryObject) selection.getFirstElement(); - - if (previewImage != null) { - previewImage.dispose(); - } - - previewImage = null; - - if (obj != null) { - if (!obj.getName().equals("noimage")) { - IFile pFile = BMotionEditorPlugin.getActiveEditor() - .getVisualization().getProjectFile(); - if (pFile != null) { - String myPath = (pFile.getProject() - .getLocationURI() + "/images/" + obj - .getName()).replace("file:", ""); - previewImage = new Image(Display.getDefault(), - myPath); - } - } - } - - previewCanvas.redraw(); - - } - - }); - - ObservableListContentProvider contentProvider = new ObservableListContentProvider(); - tvLibrary.setContentProvider(contentProvider); - - tvLibrary.getTable().setLinesVisible(true); - tvLibrary.getTable().setHeaderVisible(true); - - final TableViewerColumn column1 = new TableViewerColumn(tvLibrary, - SWT.NONE); - column1.getColumn().setText("Name"); - column1.getColumn().setWidth(390); - column1.setLabelProvider(new CellLabelProvider() { - @Override - public void update(final ViewerCell cell) { - cell.setText(((LibraryObject) cell.getElement()).getName()); - cell.setImage(((LibraryObject) cell.getElement()).getImage()); - } - }); - - final TableViewerColumn column2 = new TableViewerColumn(tvLibrary, - SWT.NONE); - column2.getColumn().setText("Type"); - column2.getColumn().setWidth(60); - column2.setLabelProvider(new CellLabelProvider() { - @Override - public void update(final ViewerCell cell) { - cell.setText(((LibraryObject) cell.getElement()).getType()); - } - }); - - WritableList input = new WritableList(getLibraryObjects(), - LibraryObject.class); - tvLibrary.setInput(input); - - return container; - - } - - private List<LibraryObject> getLibraryObjects() { - - List<LibraryObject> tmpList = new ArrayList<LibraryObject>(); - tmpList.add(new LibraryObject("noimage", "", BMotionStudioImage - .getImageDescriptor("org.eclipse.ui", - "$nl$/icons/full/etool16/delete_edit.gif") - .createImage())); - - if (BMotionEditorPlugin.getActiveEditor() != null) { - - String basePath = (BMotionEditorPlugin.getActiveEditor() - .getVisualization().getProjectFile().getProject() - .getLocation().toString()).replace("file:", ""); - File dir = new File(basePath + "/images"); - File[] fileList = dir.listFiles(new FilenameFilter() { - public boolean accept(final File dir, final String name) { - if (name.toLowerCase().endsWith(".jpg") - || name.toLowerCase().endsWith(".gif") - || name.toLowerCase().endsWith(".png")) { - return true; - } - return false; - } - }); - if (fileList != null) { - for (File f : fileList) { - Image img = null; - if (f.getName().toLowerCase().endsWith(".jpg")) { - img = BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_JPG); - } else { - img = BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_GIF); - } - tmpList.add(new LibraryImageObject(f.getName(), "image", - img)); - } - } - - } - - return tmpList; - - } - - LibraryObject getSelectedObject() { - IStructuredSelection sel = (IStructuredSelection) tvLibrary - .getSelection(); - LibraryObject lobj = (LibraryObject) sel.getFirstElement(); - return lobj; - } - - @Override - protected Point getInitialSize() { - return new Point(500, 500); - } - - @Override - protected void okPressed() { - LibraryObject sel = getSelectedObject(); - if (sel != null) { - if (!sel.getName().equals("noimage")) { - this.imageDialogCellEditor.setValue(sel.getName()); - } else { - this.imageDialogCellEditor.setValue(""); - } - - } - close(); - } - - @Override - protected void configureShell(final Shell newShell) { - super.configureShell(newShell); - newShell.setText("BMotion Studio - Select image dialog"); - } - -} +/** + * (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.bmotionstudio.gef.editor.property; + +import java.io.File; +import java.io.FilenameFilter; +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.core.resources.IFile; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.viewers.CellLabelProvider; +import org.eclipse.jface.viewers.ISelectionChangedListener; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.SelectionChangedEvent; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.TableViewerColumn; +import org.eclipse.jface.viewers.ViewerCell; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.events.PaintListener; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; + +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.BMotionStudioImage; +import de.bmotionstudio.gef.editor.EditorImageRegistry; +import de.bmotionstudio.gef.editor.library.LibraryImageObject; +import de.bmotionstudio.gef.editor.library.LibraryObject; + +public class ImageDialog extends Dialog { + + private TableViewer tvLibrary; + private Image previewImage; + private Composite preContainer; + private Canvas previewCanvas; + private final ImageDialogCellEditor imageDialogCellEditor; + + protected ImageDialog(final Shell parentShell, + final ImageDialogCellEditor imageDialogCellEditor) { + super(parentShell); + this.imageDialogCellEditor = imageDialogCellEditor; + } + + @Override + protected Control createDialogArea(final Composite parent) { + + Composite container = (Composite) super.createDialogArea(parent); + + GridLayout gl = new GridLayout(1, true); + gl.horizontalSpacing = 0; + container.setLayout(gl); + + GridData gd = new GridData(GridData.FILL_BOTH); + gd.horizontalIndent = 0; + + preContainer = new Composite(container, SWT.NONE); + preContainer.setLayoutData(gd); + preContainer.setLayout(new FillLayout()); + + previewCanvas = new Canvas(preContainer, SWT.BORDER); + previewCanvas.addPaintListener(new PaintListener() { + public void paintControl(final PaintEvent e) { + if (previewImage == null) { + e.gc.drawString("No image selected ...", 0, 0); + } else { + e.gc.drawImage(previewImage, 0, 0); + } + } + }); + + final Composite libContainer = new Composite(container, SWT.NONE); + libContainer.setLayoutData(gd); + libContainer.setLayout(new FillLayout()); + + tvLibrary = new TableViewer(libContainer, SWT.FULL_SELECTION + | SWT.V_SCROLL); + tvLibrary.getTable().setLayoutData(gd); + tvLibrary.addSelectionChangedListener(new ISelectionChangedListener() { + + public void selectionChanged(final SelectionChangedEvent event) { + + IStructuredSelection selection = (IStructuredSelection) event + .getSelection(); + + LibraryObject obj = (LibraryObject) selection.getFirstElement(); + + if (previewImage != null) { + previewImage.dispose(); + } + + previewImage = null; + + if (obj != null) { + if (!obj.getName().equals("noimage")) { + IFile pFile = BMotionEditorPlugin.getActiveEditor() + .getVisualization().getProjectFile(); + if (pFile != null) { + String myPath = (pFile.getProject() + .getLocationURI() + "/images/" + obj + .getName()).replace("file:", ""); + previewImage = new Image(Display.getDefault(), + myPath); + } + } + } + + previewCanvas.redraw(); + + } + + }); + + ObservableListContentProvider contentProvider = new ObservableListContentProvider(); + tvLibrary.setContentProvider(contentProvider); + + tvLibrary.getTable().setLinesVisible(true); + tvLibrary.getTable().setHeaderVisible(true); + + final TableViewerColumn column1 = new TableViewerColumn(tvLibrary, + SWT.NONE); + column1.getColumn().setText("Name"); + column1.getColumn().setWidth(390); + column1.setLabelProvider(new CellLabelProvider() { + @Override + public void update(final ViewerCell cell) { + cell.setText(((LibraryObject) cell.getElement()).getName()); + cell.setImage(((LibraryObject) cell.getElement()).getImage()); + } + }); + + final TableViewerColumn column2 = new TableViewerColumn(tvLibrary, + SWT.NONE); + column2.getColumn().setText("Type"); + column2.getColumn().setWidth(60); + column2.setLabelProvider(new CellLabelProvider() { + @Override + public void update(final ViewerCell cell) { + cell.setText(((LibraryObject) cell.getElement()).getType()); + } + }); + + WritableList input = new WritableList(getLibraryObjects(), + LibraryObject.class); + tvLibrary.setInput(input); + + return container; + + } + + private List<LibraryObject> getLibraryObjects() { + + List<LibraryObject> tmpList = new ArrayList<LibraryObject>(); + tmpList.add(new LibraryObject("noimage", "", BMotionStudioImage + .getImageDescriptor("org.eclipse.ui", + "$nl$/icons/full/etool16/delete_edit.gif") + .createImage())); + + if (BMotionEditorPlugin.getActiveEditor() != null) { + + String basePath = (BMotionEditorPlugin.getActiveEditor() + .getVisualization().getProjectFile().getProject() + .getLocation().toString()).replace("file:", ""); + File dir = new File(basePath + "/images"); + File[] fileList = dir.listFiles(new FilenameFilter() { + public boolean accept(final File dir, final String name) { + if (name.toLowerCase().endsWith(".jpg") + || name.toLowerCase().endsWith(".gif") + || name.toLowerCase().endsWith(".png")) { + return true; + } + return false; + } + }); + if (fileList != null) { + for (File f : fileList) { + Image img = null; + if (f.getName().toLowerCase().endsWith(".jpg")) { + img = BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_JPG); + } else { + img = BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_GIF); + } + tmpList.add(new LibraryImageObject(f.getName(), "image", + img)); + } + } + + } + + return tmpList; + + } + + LibraryObject getSelectedObject() { + IStructuredSelection sel = (IStructuredSelection) tvLibrary + .getSelection(); + LibraryObject lobj = (LibraryObject) sel.getFirstElement(); + return lobj; + } + + @Override + protected Point getInitialSize() { + return new Point(500, 500); + } + + @Override + protected void okPressed() { + LibraryObject sel = getSelectedObject(); + if (sel != null) { + if (!sel.getName().equals("noimage")) { + this.imageDialogCellEditor.setValue(sel.getName()); + } else { + this.imageDialogCellEditor.setValue(""); + } + + } + close(); + } + + @Override + protected void configureShell(final Shell newShell) { + super.configureShell(newShell); + newShell.setText("BMotion Studio - Select image dialog"); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialogCellEditor.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialogCellEditor.java index fb88890ec12650af160ae1b33131b4dade7b260d..ec77332f939ab0c106bb4d0de6ad3589e5f1bc5d 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialogCellEditor.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/property/ImageDialogCellEditor.java @@ -1,42 +1,42 @@ -/** - * (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.bmotionstudio.gef.editor.property; - -import org.eclipse.jface.dialogs.Dialog; -import org.eclipse.jface.viewers.DialogCellEditor; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.ui.PlatformUI; - -public class ImageDialogCellEditor extends DialogCellEditor { - - /** - * Creates a new Image dialog cell editor parented under the given control. - * The cell editor value is <code>null</code> initially, and has no - * validator. - * - * @param parent - * the parent control - */ - protected ImageDialogCellEditor(Composite parent) { - super(parent); - } - - /** - * @see org.eclipse.jface.viewers.DialogCellEditor#openDialogBox(Control) - */ - @Override - protected Object openDialogBox(Control arg) { - ImageDialog dialog = new ImageDialog(PlatformUI.getWorkbench() - .getActiveWorkbenchWindow().getShell(), this); - if (dialog.open() == Dialog.OK) { - return getValue(); - } - return null; - } - -} +/** + * (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.bmotionstudio.gef.editor.property; + +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.viewers.DialogCellEditor; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.ui.PlatformUI; + +public class ImageDialogCellEditor extends DialogCellEditor { + + /** + * Creates a new Image dialog cell editor parented under the given control. + * The cell editor value is <code>null</code> initially, and has no + * validator. + * + * @param parent + * the parent control + */ + protected ImageDialogCellEditor(Composite parent) { + super(parent); + } + + /** + * @see org.eclipse.jface.viewers.DialogCellEditor#openDialogBox(Control) + */ + @Override + protected Object openDialogBox(Control arg) { + ImageDialog dialog = new ImageDialog(PlatformUI.getWorkbench() + .getActiveWorkbenchWindow().getShell(), this); + if (dialog.open() == Dialog.OK) { + return getValue(); + } + return null; + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/AnimationScriptObject.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/AnimationScriptObject.java index 332a0ffad16ec57344b33dba42c7e9c43da89c86..00e57c45a0df64e0488889047607f3aaf52079c6 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/AnimationScriptObject.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/AnimationScriptObject.java @@ -16,6 +16,9 @@ public class AnimationScriptObject extends BindingObject implements Cloneable { private String predicate; + public AnimationScriptObject() { + } + public AnimationScriptObject(String predicate) { this(predicate, new Vector<AnimationScriptStep>()); } diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteAnimationScript.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteAnimationScript.java index 3b8d16f6086330968b7ed87274a724f4d7c64ae6..08af0cb8650791926392b3a2870bbc6a5c5cdd9a 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteAnimationScript.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteAnimationScript.java @@ -12,7 +12,7 @@ import java.util.Random; import de.bmotionstudio.gef.editor.internal.Animation; import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.scheduler.wizard.WizardExecuteAnimationScript; +import de.bmotionstudio.gef.editor.scheduler.wizard.WizardExecuteScheduler; import de.prob.core.Animator; import de.prob.core.command.ExecuteOperationCommand; import de.prob.core.command.GetCurrentStateIdCommand; @@ -97,7 +97,7 @@ public class ExecuteAnimationScript extends SchedulerEvent { @Override public SchedulerWizard getWizard(final BControl bcontrol) { - return new WizardExecuteAnimationScript(bcontrol, this); + return new WizardExecuteScheduler(bcontrol, this); } public ExecuteAnimationScript clone() throws CloneNotSupportedException { diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteOperationByPredicate.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteOperationByPredicate.java index 23d2a1c1c60a8cf83dc8da6ee73c2fdb8e59d3b8..1ecb2129b9b7e1595506d61aaca133d002ab4f61 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteOperationByPredicate.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/ExecuteOperationByPredicate.java @@ -11,7 +11,7 @@ import java.util.Random; import de.bmotionstudio.gef.editor.internal.Animation; import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.scheduler.wizard.WizardSchedulerExecuteOperationByPredicate; +import de.bmotionstudio.gef.editor.scheduler.wizard.WizardExecuteOperationByPredicate; import de.prob.core.Animator; import de.prob.core.command.ExecuteOperationCommand; import de.prob.core.command.GetCurrentStateIdCommand; @@ -75,7 +75,7 @@ public class ExecuteOperationByPredicate extends SchedulerEvent { @Override public SchedulerWizard getWizard(BControl bcontrol) { - return new WizardSchedulerExecuteOperationByPredicate(bcontrol, this); + return new WizardExecuteOperationByPredicate(bcontrol, this); } public void setPredicateOperation(PredicateOperation predicateOperation) { diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerEvent.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerEvent.java index c83a6510ffbf326af0990ce77a5f553651c1ca1f..1ab4d5c9f15eafeaf03b46780b189720530b93be 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerEvent.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerEvent.java @@ -1,90 +1,90 @@ -/** - * (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.bmotionstudio.gef.editor.scheduler; - -import org.eclipse.core.runtime.IConfigurationElement; - -import de.bmotionstudio.gef.editor.AbstractExpressionControl; -import de.bmotionstudio.gef.editor.BMotionEditorPlugin; -import de.bmotionstudio.gef.editor.internal.Animation; -import de.bmotionstudio.gef.editor.model.BControl; - -/** - * - * Scheduler Events are assigned to events (i.e. on-click event) or to - * schedulers. A scheduler is an independent thread attempting to execute a set - * of scheduler events. It is very useful when the user does not want to execute - * each scheduler event by hand during an animation. - * - * @author Lukas Ladenberger - * - */ -public abstract class SchedulerEvent extends AbstractExpressionControl - implements Cloneable { - - private transient String eventID; - - public SchedulerEvent() { - init(); - } - - protected Object readResolve() { - init(); - return this; - } - - /** - * Method to initialize the scheduler event. Gets the ID, name and - * description from the corresponding extension point - */ - private void init() { - IConfigurationElement configElement = BMotionEditorPlugin - .getSchedulerExtension(getClass().getName()); - if (configElement != null) { - this.ID = configElement.getAttribute("class"); - this.name = configElement.getAttribute("name"); - this.description = configElement.getAttribute("description"); - } - } - - public void setEventID(String eventID) { - this.eventID = eventID; - } - - public String getEventID() { - return eventID; - } - - /** - * Executes the scheduler event (i.e. execute operation). - * - * @param animation - * The running animation - * @param bcontrol - * The corresponding control - */ - public abstract void execute(Animation animation, BControl bcontrol); - - /** - * Returns a corresponding wizard for the scheduler event. - * - * @param bcontrol - * The corresponding control - * @return the corresponding wizard - */ - public abstract SchedulerWizard getWizard(BControl bcontrol); - - /** - * Makes a copy of the scheduler event - * - * @return the cloned scheduler event - */ - public SchedulerEvent clone() throws CloneNotSupportedException { - return (SchedulerEvent) super.clone(); - } - -} +/** + * (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.bmotionstudio.gef.editor.scheduler; + +import org.eclipse.core.runtime.IConfigurationElement; + +import de.bmotionstudio.gef.editor.AbstractExpressionControl; +import de.bmotionstudio.gef.editor.BMotionEditorPlugin; +import de.bmotionstudio.gef.editor.internal.Animation; +import de.bmotionstudio.gef.editor.model.BControl; + +/** + * + * Scheduler Events are assigned to events (i.e. on-click event) or to + * schedulers. A scheduler is an independent thread attempting to execute a set + * of scheduler events. It is very useful when the user does not want to execute + * each scheduler event by hand during an animation. + * + * @author Lukas Ladenberger + * + */ +public abstract class SchedulerEvent extends AbstractExpressionControl + implements Cloneable { + + private transient String eventID; + + public SchedulerEvent() { + init(); + } + + protected Object readResolve() { + init(); + return this; + } + + /** + * Method to initialize the scheduler event. Gets the ID, name and + * description from the corresponding extension point + */ + private void init() { + IConfigurationElement configElement = BMotionEditorPlugin + .getSchedulerExtension(getClass().getName()); + if (configElement != null) { + this.ID = configElement.getAttribute("class"); + this.name = configElement.getAttribute("name"); + this.description = configElement.getAttribute("description"); + } + } + + public void setEventID(String eventID) { + this.eventID = eventID; + } + + public String getEventID() { + return eventID; + } + + /** + * Executes the scheduler event (i.e. execute operation). + * + * @param animation + * The running animation + * @param bcontrol + * The corresponding control + */ + public abstract void execute(Animation animation, BControl bcontrol); + + /** + * Returns a corresponding wizard for the scheduler event. + * + * @param bcontrol + * The corresponding control + * @return the corresponding wizard + */ + public abstract SchedulerWizard getWizard(BControl bcontrol); + + /** + * Makes a copy of the scheduler event + * + * @return the cloned scheduler event + */ + public SchedulerEvent clone() throws CloneNotSupportedException { + return (SchedulerEvent) super.clone(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerWizard.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerWizard.java index 61cd3a464efda46d1de02480cce6afa177cabcc0..fd6aa87f28e9051361391029c7bc4cc26b08f8e2 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerWizard.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/SchedulerWizard.java @@ -1,60 +1,65 @@ -/** - * (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.bmotionstudio.gef.editor.scheduler; - -import org.eclipse.jface.wizard.Wizard; -import org.eclipse.swt.graphics.Point; - -import de.bmotionstudio.gef.editor.model.BControl; - -/** - * - * The BMotion Studio provides an easy way to handle Scheduler Events. For this, - * Scheduler Events can have a corresponding dialog. The user can open it by - * calling the context menu of a B-Control. - * - * @author Lukas Ladenberger - * - */ -public abstract class SchedulerWizard extends Wizard { - - private BControl bcontrol; - private SchedulerEvent event; - - protected Boolean eventDelete = false; - - public SchedulerWizard(BControl bcontrol, SchedulerEvent scheduler) { - this.bcontrol = bcontrol; - this.event = scheduler; - } - - public BControl getBControl() { - return this.bcontrol; - } - - public SchedulerEvent getScheduler() { - return this.event; - } - - protected abstract Boolean prepareToFinish(); - - @Override - public boolean performFinish() { - return prepareToFinish(); - } - - protected void setEventDelete(Boolean b) { - this.eventDelete = b; - } - - public Boolean isEventDelete() { - return this.eventDelete; - } - - public abstract Point getSize(); - -} +/** + * (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.bmotionstudio.gef.editor.scheduler; + +import org.eclipse.swt.graphics.Point; + +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; +import de.bmotionstudio.gef.editor.model.BControl; + +/** + * + * The BMotion Studio provides an easy way to handle Scheduler Events. For this, + * Scheduler Events can have a corresponding dialog. The user can open it by + * calling the context menu of a B-Control. + * + * @author Lukas Ladenberger + * + */ +public abstract class SchedulerWizard extends BMotionAbstractWizard { + + private BControl bcontrol; + private SchedulerEvent event; + + protected Boolean eventDelete = false; + + public SchedulerWizard(BControl bcontrol, SchedulerEvent scheduler) { + this.bcontrol = bcontrol; + this.event = scheduler; + } + + public BControl getBControl() { + return this.bcontrol; + } + + public SchedulerEvent getScheduler() { + return this.event; + } + + protected abstract Boolean prepareToFinish(); + + @Override + public boolean performFinish() { + return prepareToFinish(); + } + + protected void setEventDelete(Boolean b) { + this.eventDelete = b; + } + + public Boolean isEventDelete() { + return this.eventDelete; + } + + public abstract Point getSize(); + + @Override + public String getName() { + return event.getName(); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/ObserverCallBackDialog.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/ObserverCallBackDialog.java index aa06b77236e917a94b64527e61ac52f97732b565..568c5f0922ff44ead8f3173c40249ec7e669bf41 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/ObserverCallBackDialog.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/ObserverCallBackDialog.java @@ -1,335 +1,335 @@ -/** - * (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.bmotionstudio.gef.editor.scheduler.wizard; - -import java.util.ArrayList; -import java.util.List; - -import org.eclipse.core.databinding.beans.BeansObservables; -import org.eclipse.core.databinding.observable.list.ComputedList; -import org.eclipse.core.databinding.observable.list.WritableList; -import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; -import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; -import org.eclipse.jface.dialogs.Dialog; -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.jface.viewers.ComboBoxViewerCellEditor; -import org.eclipse.jface.viewers.EditingSupport; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.viewers.TableViewerColumn; -import org.eclipse.swt.SWT; -import org.eclipse.swt.custom.CCombo; -import org.eclipse.swt.events.FocusEvent; -import org.eclipse.swt.events.FocusListener; -import org.eclipse.swt.events.SelectionAdapter; -import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.layout.RowLayout; -import org.eclipse.swt.widgets.Button; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; - -import de.bmotionstudio.gef.editor.BMotionStudioImage; -import de.bmotionstudio.gef.editor.EditorImageRegistry; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.scheduler.AnimationScriptStep; -import de.bmotionstudio.gef.editor.scheduler.ObserverCallBackObject; - -@Deprecated -public class ObserverCallBackDialog extends Dialog { - - private TableViewer tableViewer; - - private final AnimationScriptStep animationScriptStep; - - private final BControl control; - - // private IObservableValue controlObservable; - - public ObserverCallBackDialog(final Shell parentShell, - final AnimationScriptStep animationScriptStep, - final BControl control) { - super(parentShell); - this.animationScriptStep = animationScriptStep; - this.control = control; - } - - @Override - protected Control createDialogArea(final Composite parent) { - - // DataBindingContext dbc = new DataBindingContext(); - - Composite container = (Composite) super.createDialogArea(parent); - container.setLayout(new GridLayout(1, true)); - - tableViewer = new TableViewer(container, SWT.BORDER - | SWT.FULL_SELECTION); - tableViewer.getTable().setLinesVisible(true); - tableViewer.getTable().setHeaderVisible(true); - tableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH)); - tableViewer.getTable().setFont( - new Font(Display.getDefault(), new FontData("Arial", 10, - SWT.NONE))); - - TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE); - column.getColumn().setText("Control"); - column.getColumn().setWidth(225); - column.setEditingSupport(new ControlValueEditing(tableViewer, control)); - - column = new TableViewerColumn(tableViewer, SWT.NONE); - column.getColumn().setText("Observer"); - column.getColumn().setWidth(150); - // column.setEditingSupport(new TextEditingSupport(tableViewer, dbc, - // "observerID")); - column.setEditingSupport(new ObserverValueEditing(tableViewer, control)); - - ObservableListContentProvider contentProvider = new ObservableListContentProvider(); - tableViewer.setContentProvider(contentProvider); - tableViewer.setLabelProvider(new ObservableMapLabelProvider( - BeansObservables.observeMaps( - contentProvider.getKnownElements(), new String[] { - "control", "observerID" })) { - - @Override - public String getColumnText(final Object element, - final int columnIndex) { - if (columnIndex == 0) { - - ObserverCallBackObject obj = (ObserverCallBackObject) element; - - if (obj.getControl() != null) { - return obj.getControl().getID(); - } - } - return super.getColumnText(element, columnIndex); - } - - @Override - public Image getColumnImage(final Object element, - final int columnIndex) { - return null; - } - - }); - - final WritableList input = new WritableList( - animationScriptStep.getCallBackList(), - ObserverCallBackObject.class); - - tableViewer.setInput(input); - - Composite comp = new Composite(container, SWT.NONE); - comp.setLayout(new RowLayout()); - comp.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END)); - - Button btRemove = new Button(comp, SWT.PUSH); - btRemove.setText("Remove"); - btRemove.setImage(BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_DELETE)); - btRemove.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(final SelectionEvent e) { - if (tableViewer.getSelection().isEmpty()) { - return; - } - ObserverCallBackObject obj = (ObserverCallBackObject) ((IStructuredSelection) tableViewer - .getSelection()).getFirstElement(); - input.remove(obj); - } - }); - - Button btAdd = new Button(comp, SWT.PUSH); - btAdd.setText("Add"); - btAdd.setImage(BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_ADD)); - btAdd.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(final SelectionEvent e) { - ObserverCallBackObject obj = new ObserverCallBackObject(); - input.add(obj); - } - }); - - return container; - - } - - @Override - protected Point getInitialSize() { - return new Point(600, 500); - } - - @Override - protected void okPressed() { - close(); - } - - @Override - protected void configureShell(final Shell newShell) { - super.configureShell(newShell); - newShell.setText("BMotion Studio - Observer Callback Editor"); - } - - private class ControlValueEditing extends EditingSupport { - - private ComboBoxViewerCellEditor cellEditor = null; - - private final BControl control; - - public ControlValueEditing(final TableViewer cv, final BControl control) { - super(cv); - this.control = control; - } - - @Override - protected boolean canEdit(final Object element) { - return true; - } - - @Override - protected Object getValue(final Object element) { - if (((ObserverCallBackObject) element).getControl() != null) { - return ((ObserverCallBackObject) element).getControl().getID(); - } else { - return ""; - } - } - - @Override - protected void setValue(final Object element, final Object value) { - if (value != null) { - ((ObserverCallBackObject) element).setControl(control - .getVisualization().getBControl(value.toString())); - } - } - - @Override - protected CellEditor getCellEditor(final Object element) { - if (cellEditor == null) { - cellEditor = new ComboBoxViewerCellEditor( - (Composite) getViewer().getControl(), SWT.READ_ONLY); - cellEditor - .setContenProvider(new ObservableListContentProvider()); - cellEditor.setInput(new ComputedList() { - @Override - protected List<String> calculate() { - ArrayList<String> tmpList = new ArrayList<String>(); - for (String controlID : control.getVisualization() - .getAllBControlIDs()) { - tmpList.add(controlID); - } - return tmpList; - } - }); - ((CCombo) cellEditor.getControl()) - .addFocusListener(new FocusListener() { - - String oldValue; - - public void focusGained(final FocusEvent e) { - oldValue = ((CCombo) cellEditor.getControl()) - .getText(); - - } - - public void focusLost(final FocusEvent e) { - - if (!oldValue.equals(((CCombo) cellEditor - .getControl()).getText())) { - - IStructuredSelection selection = (IStructuredSelection) getViewer() - .getSelection(); - - ObserverCallBackObject obj = (ObserverCallBackObject) selection - .getFirstElement(); - obj.setObserverID(""); - tableViewer.refresh(); - - } - } - - }); - } - return cellEditor; - } - } - - private static class ObserverValueEditing extends EditingSupport { - - private ComboBoxViewerCellEditor cellEditor = null; - - // private final BControl control; - - public ObserverValueEditing(final TableViewer cv, final BControl control) { - super(cv); - // this.control = control; - } - - @Override - protected boolean canEdit(final Object element) { - return true; - } - - @Override - protected Object getValue(final Object element) { - if (((ObserverCallBackObject) element).getObserverID() != null) { - return ((ObserverCallBackObject) element).getObserverID(); - } else { - return ""; - } - } - - @Override - protected void setValue(final Object element, final Object value) { - if (value != null) { - ((ObserverCallBackObject) element).setObserverID(value - .toString()); - } - } - - @Override - protected CellEditor getCellEditor(final Object element) { - - if (cellEditor == null) { - cellEditor = new ComboBoxViewerCellEditor( - (Composite) getViewer().getControl(), SWT.READ_ONLY); - cellEditor - .setContenProvider(new ObservableListContentProvider()); - } - // cellEditor.setInput(new ComputedList() { - // @Override - // protected List<String> calculate() { - // - // ArrayList<String> tmpList = new ArrayList<String>(); - // - // ObserverCallBackObject obj = (ObserverCallBackObject) element; - // BControl control = obj.getControl(); - // if (control != null) { - // - // for (String id : control.getObservers().keySet()) { - // tmpList.add(id); - // } - // - // } - // - // return tmpList; - // - // } - // }); - - return cellEditor; - } - } - -} +/** + * (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.bmotionstudio.gef.editor.scheduler.wizard; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.core.databinding.observable.list.ComputedList; +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.ComboBoxViewerCellEditor; +import org.eclipse.jface.viewers.EditingSupport; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.TableViewerColumn; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.CCombo; +import org.eclipse.swt.events.FocusEvent; +import org.eclipse.swt.events.FocusListener; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.layout.RowLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; + +import de.bmotionstudio.gef.editor.BMotionStudioImage; +import de.bmotionstudio.gef.editor.EditorImageRegistry; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.scheduler.AnimationScriptStep; +import de.bmotionstudio.gef.editor.scheduler.ObserverCallBackObject; + +@Deprecated +public class ObserverCallBackDialog extends Dialog { + + private TableViewer tableViewer; + + private final AnimationScriptStep animationScriptStep; + + private final BControl control; + + // private IObservableValue controlObservable; + + public ObserverCallBackDialog(final Shell parentShell, + final AnimationScriptStep animationScriptStep, + final BControl control) { + super(parentShell); + this.animationScriptStep = animationScriptStep; + this.control = control; + } + + @Override + protected Control createDialogArea(final Composite parent) { + + // DataBindingContext dbc = new DataBindingContext(); + + Composite container = (Composite) super.createDialogArea(parent); + container.setLayout(new GridLayout(1, true)); + + tableViewer = new TableViewer(container, SWT.BORDER + | SWT.FULL_SELECTION); + tableViewer.getTable().setLinesVisible(true); + tableViewer.getTable().setHeaderVisible(true); + tableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH)); + tableViewer.getTable().setFont( + new Font(Display.getDefault(), new FontData("Arial", 10, + SWT.NONE))); + + TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE); + column.getColumn().setText("Control"); + column.getColumn().setWidth(225); + column.setEditingSupport(new ControlValueEditing(tableViewer, control)); + + column = new TableViewerColumn(tableViewer, SWT.NONE); + column.getColumn().setText("Observer"); + column.getColumn().setWidth(150); + // column.setEditingSupport(new TextEditingSupport(tableViewer, dbc, + // "observerID")); + column.setEditingSupport(new ObserverValueEditing(tableViewer, control)); + + ObservableListContentProvider contentProvider = new ObservableListContentProvider(); + tableViewer.setContentProvider(contentProvider); + tableViewer.setLabelProvider(new ObservableMapLabelProvider( + BeansObservables.observeMaps( + contentProvider.getKnownElements(), new String[] { + "control", "observerID" })) { + + @Override + public String getColumnText(final Object element, + final int columnIndex) { + if (columnIndex == 0) { + + ObserverCallBackObject obj = (ObserverCallBackObject) element; + + if (obj.getControl() != null) { + return obj.getControl().getID(); + } + } + return super.getColumnText(element, columnIndex); + } + + @Override + public Image getColumnImage(final Object element, + final int columnIndex) { + return null; + } + + }); + + final WritableList input = new WritableList( + animationScriptStep.getCallBackList(), + ObserverCallBackObject.class); + + tableViewer.setInput(input); + + Composite comp = new Composite(container, SWT.NONE); + comp.setLayout(new RowLayout()); + comp.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END)); + + Button btRemove = new Button(comp, SWT.PUSH); + btRemove.setText("Remove"); + btRemove.setImage(BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_DELETE)); + btRemove.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(final SelectionEvent e) { + if (tableViewer.getSelection().isEmpty()) { + return; + } + ObserverCallBackObject obj = (ObserverCallBackObject) ((IStructuredSelection) tableViewer + .getSelection()).getFirstElement(); + input.remove(obj); + } + }); + + Button btAdd = new Button(comp, SWT.PUSH); + btAdd.setText("Add"); + btAdd.setImage(BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_ADD)); + btAdd.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(final SelectionEvent e) { + ObserverCallBackObject obj = new ObserverCallBackObject(); + input.add(obj); + } + }); + + return container; + + } + + @Override + protected Point getInitialSize() { + return new Point(600, 500); + } + + @Override + protected void okPressed() { + close(); + } + + @Override + protected void configureShell(final Shell newShell) { + super.configureShell(newShell); + newShell.setText("BMotion Studio - Observer Callback Editor"); + } + + private class ControlValueEditing extends EditingSupport { + + private ComboBoxViewerCellEditor cellEditor = null; + + private final BControl control; + + public ControlValueEditing(final TableViewer cv, final BControl control) { + super(cv); + this.control = control; + } + + @Override + protected boolean canEdit(final Object element) { + return true; + } + + @Override + protected Object getValue(final Object element) { + if (((ObserverCallBackObject) element).getControl() != null) { + return ((ObserverCallBackObject) element).getControl().getID(); + } else { + return ""; + } + } + + @Override + protected void setValue(final Object element, final Object value) { + if (value != null) { + ((ObserverCallBackObject) element).setControl(control + .getVisualization().getBControl(value.toString())); + } + } + + @Override + protected CellEditor getCellEditor(final Object element) { + if (cellEditor == null) { + cellEditor = new ComboBoxViewerCellEditor( + (Composite) getViewer().getControl(), SWT.READ_ONLY); + cellEditor + .setContenProvider(new ObservableListContentProvider()); + cellEditor.setInput(new ComputedList() { + @Override + protected List<String> calculate() { + ArrayList<String> tmpList = new ArrayList<String>(); + for (String controlID : control.getVisualization() + .getAllBControlIDs()) { + tmpList.add(controlID); + } + return tmpList; + } + }); + ((CCombo) cellEditor.getControl()) + .addFocusListener(new FocusListener() { + + String oldValue; + + public void focusGained(final FocusEvent e) { + oldValue = ((CCombo) cellEditor.getControl()) + .getText(); + + } + + public void focusLost(final FocusEvent e) { + + if (!oldValue.equals(((CCombo) cellEditor + .getControl()).getText())) { + + IStructuredSelection selection = (IStructuredSelection) getViewer() + .getSelection(); + + ObserverCallBackObject obj = (ObserverCallBackObject) selection + .getFirstElement(); + obj.setObserverID(""); + tableViewer.refresh(); + + } + } + + }); + } + return cellEditor; + } + } + + private static class ObserverValueEditing extends EditingSupport { + + private ComboBoxViewerCellEditor cellEditor = null; + + // private final BControl control; + + public ObserverValueEditing(final TableViewer cv, final BControl control) { + super(cv); + // this.control = control; + } + + @Override + protected boolean canEdit(final Object element) { + return true; + } + + @Override + protected Object getValue(final Object element) { + if (((ObserverCallBackObject) element).getObserverID() != null) { + return ((ObserverCallBackObject) element).getObserverID(); + } else { + return ""; + } + } + + @Override + protected void setValue(final Object element, final Object value) { + if (value != null) { + ((ObserverCallBackObject) element).setObserverID(value + .toString()); + } + } + + @Override + protected CellEditor getCellEditor(final Object element) { + + if (cellEditor == null) { + cellEditor = new ComboBoxViewerCellEditor( + (Composite) getViewer().getControl(), SWT.READ_ONLY); + cellEditor + .setContenProvider(new ObservableListContentProvider()); + } + // cellEditor.setInput(new ComputedList() { + // @Override + // protected List<String> calculate() { + // + // ArrayList<String> tmpList = new ArrayList<String>(); + // + // ObserverCallBackObject obj = (ObserverCallBackObject) element; + // BControl control = obj.getControl(); + // if (control != null) { + // + // for (String id : control.getObservers().keySet()) { + // tmpList.add(id); + // } + // + // } + // + // return tmpList; + // + // } + // }); + + return cellEditor; + } + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/AnimationScriptObjectDialog.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/SchedulerObjectDialog.java similarity index 63% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/AnimationScriptObjectDialog.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/SchedulerObjectDialog.java index 614a93d8fad62dfee190e40e4e9249ff8400788d..af904c2fb0b042b4581c3df6c17ace2d41fa8111 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/AnimationScriptObjectDialog.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/SchedulerObjectDialog.java @@ -1,407 +1,287 @@ -/** - * (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.bmotionstudio.gef.editor.scheduler.wizard; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Vector; - -import org.eclipse.core.databinding.DataBindingContext; -import org.eclipse.core.databinding.beans.BeansObservables; -import org.eclipse.core.databinding.observable.list.ComputedList; -import org.eclipse.core.databinding.observable.list.WritableList; -import org.eclipse.core.resources.IFile; -import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; -import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; -import org.eclipse.jface.dialogs.Dialog; -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.jface.viewers.ColumnViewer; -import org.eclipse.jface.viewers.ComboBoxViewerCellEditor; -import org.eclipse.jface.viewers.EditingSupport; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.viewers.TableViewerColumn; -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.SelectionAdapter; -import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.layout.RowLayout; -import org.eclipse.swt.widgets.Button; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Shell; -import org.eventb.core.IMachineRoot; -import org.eventb.core.ISCEvent; -import org.eventb.core.ISCGuard; -import org.eventb.core.ISCMachineRoot; -import org.eventb.core.ISCParameter; -import org.rodinp.core.IRodinFile; -import org.rodinp.core.IRodinProject; -import org.rodinp.core.RodinCore; -import org.rodinp.core.RodinDBException; - -import de.bmotionstudio.gef.editor.BMotionStudioImage; -import de.bmotionstudio.gef.editor.EditorImageRegistry; -import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; -import de.bmotionstudio.gef.editor.eventb.EventBHelper; -import de.bmotionstudio.gef.editor.eventb.MachineContentObject; -import de.bmotionstudio.gef.editor.eventb.MachineOperation; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.model.Visualization; -import de.bmotionstudio.gef.editor.property.IntegerCellEditor; -import de.bmotionstudio.gef.editor.scheduler.AnimationScriptObject; -import de.bmotionstudio.gef.editor.scheduler.AnimationScriptStep; -import de.prob.logging.Logger; - -public class AnimationScriptObjectDialog extends Dialog { - - private ISCMachineRoot getCorrespondingFile(IFile file, - String machineFileName) { - IRodinProject myProject = RodinCore.valueOf(file.getProject()); - IRodinFile rodinSource = myProject.getRodinFile(machineFileName); - ISCMachineRoot machineRoot = ((IMachineRoot) rodinSource.getRoot()) - .getSCMachineRoot(); - return machineRoot; - } - - public List<MachineContentObject> getOperations(Visualization visualization) { - - ISCMachineRoot machineRoot = null; - - machineRoot = getCorrespondingFile(visualization.getProjectFile(), - visualization.getMachineName()); - - ISCEvent[] events = null; - ArrayList<MachineContentObject> tmpSet = new ArrayList<MachineContentObject>(); - - try { - events = machineRoot.getSCEvents(); - - for (ISCEvent event : events) { - - Vector<String> parSet = new Vector<String>(); - Vector<String> guardSet = new Vector<String>(); - - for (ISCParameter par : event.getSCParameters()) { - parSet.insertElementAt(par.getIdentifierString(), - parSet.size()); - } - - for (ISCGuard guard : event.getSCGuards()) { - guardSet.insertElementAt(guard.getPredicateString(), - guardSet.size()); - } - - MachineOperation op = new MachineOperation(event.getLabel(), - parSet, guardSet); - tmpSet.add(op); - - } - } catch (RodinDBException e) { - String message = "Rodin DB Exception while getting operations: " - + e.getLocalizedMessage(); - Logger.notifyUser(message, e); - return Collections - .unmodifiableList(new ArrayList<MachineContentObject>()); - } - - return tmpSet; - - } - - private TableViewer tableViewer; - - private final BControl control; - - private AnimationScriptObject animationScriptObject; - - public AnimationScriptObjectDialog(Shell parentShell, BControl control, - AnimationScriptObject animationScriptObject) { - super(parentShell); - this.control = control; - this.animationScriptObject = animationScriptObject; - } - - @Override - protected Control createDialogArea(final Composite parent) { - - DataBindingContext dbc = new DataBindingContext(); - - Composite container = (Composite) super.createDialogArea(parent); - container.setLayout(new GridLayout(1, true)); - - tableViewer = new TableViewer(container, SWT.BORDER - | SWT.FULL_SELECTION); - tableViewer.getTable().setLinesVisible(true); - tableViewer.getTable().setHeaderVisible(true); - tableViewer.getTable().setLayoutData(new GridData(GridData.FILL_BOTH)); - tableViewer.getTable().setFont( - new Font(Display.getDefault(), new FontData("Arial", 10, - SWT.NONE))); - - TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE); - column.getColumn().setText("Operation"); - column.getColumn().setWidth(175); - column.setEditingSupport(new OperationValueEditing(tableViewer, control)); - - column = new TableViewerColumn(tableViewer, SWT.NONE); - column.getColumn().setText("Predicate"); - column.getColumn().setWidth(300); - column.setEditingSupport(new PredicateEditingSupport(tableViewer, dbc, - "parameter", control.getVisualization(), getShell())); - - column = new TableViewerColumn(tableViewer, SWT.NONE); - column.getColumn().setText("Random Ops"); - column.getColumn().setWidth(100); - column.setEditingSupport(new RandomModeEditingSupport(tableViewer)); - - // column = new TableViewerColumn(tableViewer, SWT.NONE); - // column.getColumn().setText("Callback"); - // column.getColumn().setWidth(100); - // column - // .setEditingSupport(new ObserverCallbackEditingSupport( - // tableViewer)); - - ObservableListContentProvider contentProvider = new ObservableListContentProvider(); - tableViewer.setContentProvider(contentProvider); - tableViewer.setLabelProvider(new ObservableMapLabelProvider( - BeansObservables.observeMaps( - contentProvider.getKnownElements(), new String[] { - "command", "parameter", "maxrandom" })) { - - @Override - public String getColumnText(final Object element, - final int columnIndex) { - // if (columnIndex == 2) { - // return "Edit"; - // } - return super.getColumnText(element, columnIndex); - } - - @Override - public Image getColumnImage(final Object element, - final int columnIndex) { - return null; - } - - }); - - final WritableList input = new WritableList( - animationScriptObject.getSteps(), AnimationScriptStep.class); - - tableViewer.setInput(input); - - Composite comp = new Composite(container, SWT.NONE); - comp.setLayout(new RowLayout()); - comp.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END)); - - Button btRemove = new Button(comp, SWT.PUSH); - btRemove.setText("Remove"); - btRemove.setImage(BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_DELETE)); - btRemove.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(final SelectionEvent e) { - if (tableViewer.getSelection().isEmpty()) { - return; - } - AnimationScriptStep obj = (AnimationScriptStep) ((IStructuredSelection) tableViewer - .getSelection()).getFirstElement(); - input.remove(obj); - } - }); - - Button btAdd = new Button(comp, SWT.PUSH); - btAdd.setText("Add"); - btAdd.setImage(BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_ADD)); - btAdd.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(final SelectionEvent e) { - AnimationScriptStep obj = new AnimationScriptStep(); - input.add(obj); - } - }); - - return container; - - } - - @Override - protected Point getInitialSize() { - return new Point(600, 500); - } - - @Override - protected void okPressed() { - close(); - } - - @Override - protected void configureShell(final Shell newShell) { - super.configureShell(newShell); - newShell.setText("BMotion Studio - Scheduler Editor"); - } - - public void setAnimationScriptObject( - final AnimationScriptObject animationScriptObject) { - this.animationScriptObject = animationScriptObject; - } - - public AnimationScriptObject getAnimationScriptObject() { - return animationScriptObject; - } - - // private class ObserverCallbackEditingSupport extends EditingSupport { - // - // public ObserverCallbackEditingSupport(ColumnViewer viewer) { - // super(viewer); - // } - // - // @Override - // protected boolean canEdit(Object element) { - // return true; - // } - // - // @Override - // protected CellEditor getCellEditor(Object element) { - // return new ObserverCallbackCellEditor((Composite) getViewer() - // .getControl(), (AnimationScriptStep) element); - // } - // - // @Override - // protected Object getValue(Object element) { - // return "Edit"; - // } - // - // @Override - // protected void setValue(Object element, Object value) { - // } - // - // } - - // private class ObserverCallbackCellEditor extends DialogCellEditor { - // - // private final AnimationScriptStep step; - // - // public ObserverCallbackCellEditor(final Composite parent, - // final AnimationScriptStep step) { - // super(parent); - // this.step = step; - // } - // - // @Override - // protected Object openDialogBox(final Control cellEditorWindow) { - // ObserverCallBackDialog dialog = new ObserverCallBackDialog( - // PlatformUI.getWorkbench().getActiveWorkbenchWindow() - // .getShell(), step, control); - // if (dialog.open() == Dialog.OK) { - // return getValue(); - // } - // return null; - // } - // - // } - - private static class OperationValueEditing extends EditingSupport { - - private ComboBoxViewerCellEditor cellEditor = null; - - private final BControl control; - - public OperationValueEditing(final TableViewer cv, - final BControl control) { - super(cv); - this.control = control; - } - - @Override - protected boolean canEdit(final Object element) { - return true; - } - - @Override - protected Object getValue(final Object element) { - return ((AnimationScriptStep) element).getCommand(); - } - - @Override - protected void setValue(final Object element, final Object value) { - if (value != null) { - ((AnimationScriptStep) element).setCommand(value.toString()); - } - } - - @Override - protected CellEditor getCellEditor(final Object element) { - if (cellEditor == null) { - cellEditor = new ComboBoxViewerCellEditor( - (Composite) getViewer().getControl(), SWT.READ_ONLY); - cellEditor - .setContentProvider(new ObservableListContentProvider()); - cellEditor.setInput(new ComputedList() { - @Override - protected List<String> calculate() { - ArrayList<String> tmpList = new ArrayList<String>(); - for (MachineContentObject op : EventBHelper - .getOperations(control.getVisualization())) { - tmpList.add(((MachineOperation) op).getLabel()); - } - return tmpList; - } - }); - } - return cellEditor; - } - } - - private static class RandomModeEditingSupport extends EditingSupport { - - private CellEditor cellEditor; - - public RandomModeEditingSupport(ColumnViewer viewer) { - super(viewer); - } - - @Override - protected void setValue(Object element, Object value) { - if (value != null) { - Integer maxnr = Integer.valueOf(value.toString()); - AnimationScriptStep obj = (AnimationScriptStep) element; - obj.setMaxrandom(maxnr); - } - } - - @Override - protected Object getValue(Object element) { - return ((AnimationScriptStep) element).getMaxrandom(); - } - - @Override - protected CellEditor getCellEditor(Object element) { - if (cellEditor == null) { - cellEditor = new IntegerCellEditor((Composite) getViewer() - .getControl()); - } - return cellEditor; - } - - @Override - protected boolean canEdit(Object element) { - return true; - } - - } - -} +/** + * (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.bmotionstudio.gef.editor.scheduler.wizard; + +import org.eclipse.core.databinding.DataBindingContext; +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.ColumnViewer; +import org.eclipse.jface.viewers.EditingSupport; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.TableViewerColumn; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.layout.RowLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Shell; + +import de.bmotionstudio.gef.editor.BMotionStudioImage; +import de.bmotionstudio.gef.editor.EditorImageRegistry; +import de.bmotionstudio.gef.editor.edit.OperationValueEditingSupport; +import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.property.IntegerCellEditor; +import de.bmotionstudio.gef.editor.scheduler.AnimationScriptObject; +import de.bmotionstudio.gef.editor.scheduler.AnimationScriptStep; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; + +public class SchedulerObjectDialog extends Dialog { + + private TableViewer tableViewer; + + private final BControl control; + + private AnimationScriptObject animationScriptObject; + + public SchedulerObjectDialog(Shell parentShell, BControl control, + AnimationScriptObject animationScriptObject) { + super(parentShell); + this.control = control; + this.animationScriptObject = animationScriptObject; + } + + @Override + protected Control createDialogArea(final Composite parent) { + + DataBindingContext dbc = new DataBindingContext(); + + Composite container = (Composite) super.createDialogArea(parent); + container.setLayout(new GridLayout(1, true)); + + tableViewer = BMotionWizardUtil + .createBMotionWizardTableViewer(container, + AnimationScriptStep.class, "Scheduler Object Dialog"); + + TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE); + column.getColumn().setText("Operation"); + column.getColumn().setWidth(175); + column.setEditingSupport(new OperationValueEditingSupport(tableViewer, + control) { + + @Override + protected Object getValue(Object element) { + return ((AnimationScriptStep) element).getCommand(); + } + + @Override + protected void setValue(Object element, Object value) { + if (value != null) + ((AnimationScriptStep) element).setCommand(value.toString()); + } + + }); + + column = new TableViewerColumn(tableViewer, SWT.NONE); + column.getColumn().setText("Predicate"); + column.getColumn().setWidth(300); + column.setEditingSupport(new PredicateEditingSupport(tableViewer, dbc, + "parameter", control.getVisualization(), getShell())); + + column = new TableViewerColumn(tableViewer, SWT.NONE); + column.getColumn().setText("Random Ops"); + column.getColumn().setWidth(100); + column.setEditingSupport(new RandomModeEditingSupport(tableViewer)); + + // column = new TableViewerColumn(tableViewer, SWT.NONE); + // column.getColumn().setText("Callback"); + // column.getColumn().setWidth(100); + // column + // .setEditingSupport(new ObserverCallbackEditingSupport( + // tableViewer)); + + ObservableListContentProvider contentProvider = new ObservableListContentProvider(); + tableViewer.setContentProvider(contentProvider); + tableViewer.setLabelProvider(new ObservableMapLabelProvider( + BeansObservables.observeMaps( + contentProvider.getKnownElements(), new String[] { + "command", "parameter", "maxrandom" })) { + + @Override + public String getColumnText(final Object element, + final int columnIndex) { + // if (columnIndex == 2) { + // return "Edit"; + // } + return super.getColumnText(element, columnIndex); + } + + @Override + public Image getColumnImage(final Object element, + final int columnIndex) { + return null; + } + + }); + + final WritableList input = new WritableList( + animationScriptObject.getSteps(), AnimationScriptStep.class); + + tableViewer.setInput(input); + + Composite comp = new Composite(container, SWT.NONE); + comp.setLayout(new RowLayout()); + comp.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END)); + + Button btRemove = new Button(comp, SWT.PUSH); + btRemove.setText("Remove"); + btRemove.setImage(BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_DELETE)); + btRemove.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(final SelectionEvent e) { + if (tableViewer.getSelection().isEmpty()) { + return; + } + AnimationScriptStep obj = (AnimationScriptStep) ((IStructuredSelection) tableViewer + .getSelection()).getFirstElement(); + input.remove(obj); + } + }); + + Button btAdd = new Button(comp, SWT.PUSH); + btAdd.setText("Add"); + btAdd.setImage(BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_ADD)); + btAdd.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(final SelectionEvent e) { + AnimationScriptStep obj = new AnimationScriptStep(); + input.add(obj); + } + }); + + return container; + + } + + @Override + protected Point getInitialSize() { + return new Point(600, 500); + } + + @Override + protected void okPressed() { + close(); + } + + @Override + protected void configureShell(final Shell newShell) { + super.configureShell(newShell); + newShell.setText("BMotion Studio - Scheduler Editor"); + } + + public void setAnimationScriptObject( + final AnimationScriptObject animationScriptObject) { + this.animationScriptObject = animationScriptObject; + } + + public AnimationScriptObject getAnimationScriptObject() { + return animationScriptObject; + } + + // private class ObserverCallbackEditingSupport extends EditingSupport { + // + // public ObserverCallbackEditingSupport(ColumnViewer viewer) { + // super(viewer); + // } + // + // @Override + // protected boolean canEdit(Object element) { + // return true; + // } + // + // @Override + // protected CellEditor getCellEditor(Object element) { + // return new ObserverCallbackCellEditor((Composite) getViewer() + // .getControl(), (AnimationScriptStep) element); + // } + // + // @Override + // protected Object getValue(Object element) { + // return "Edit"; + // } + // + // @Override + // protected void setValue(Object element, Object value) { + // } + // + // } + + // private class ObserverCallbackCellEditor extends DialogCellEditor { + // + // private final AnimationScriptStep step; + // + // public ObserverCallbackCellEditor(final Composite parent, + // final AnimationScriptStep step) { + // super(parent); + // this.step = step; + // } + // + // @Override + // protected Object openDialogBox(final Control cellEditorWindow) { + // ObserverCallBackDialog dialog = new ObserverCallBackDialog( + // PlatformUI.getWorkbench().getActiveWorkbenchWindow() + // .getShell(), step, control); + // if (dialog.open() == Dialog.OK) { + // return getValue(); + // } + // return null; + // } + // + // } + + private static class RandomModeEditingSupport extends EditingSupport { + + private CellEditor cellEditor; + + public RandomModeEditingSupport(ColumnViewer viewer) { + super(viewer); + } + + @Override + protected void setValue(Object element, Object value) { + if (value != null) { + Integer maxnr = Integer.valueOf(value.toString()); + AnimationScriptStep obj = (AnimationScriptStep) element; + obj.setMaxrandom(maxnr); + } + } + + @Override + protected Object getValue(Object element) { + return ((AnimationScriptStep) element).getMaxrandom(); + } + + @Override + protected CellEditor getCellEditor(Object element) { + if (cellEditor == null) { + cellEditor = new IntegerCellEditor((Composite) getViewer() + .getControl()); + } + return cellEditor; + } + + @Override + protected boolean canEdit(Object element) { + return true; + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardSchedulerExecuteOperationByPredicate.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicate.java similarity index 95% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardSchedulerExecuteOperationByPredicate.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicate.java index c1bc11d03e21e65717db4536a2dc3c0b29f9a846..b30b1e9da463f67e424610302dd529e9e330a08c 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardSchedulerExecuteOperationByPredicate.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicate.java @@ -1,323 +1,323 @@ -/** - * (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.bmotionstudio.gef.editor.scheduler.wizard; - -import org.eclipse.core.databinding.DataBindingContext; -import org.eclipse.core.databinding.beans.BeansObservables; -import org.eclipse.core.databinding.observable.list.WritableList; -import org.eclipse.core.databinding.observable.map.IObservableMap; -import org.eclipse.core.databinding.observable.value.IObservableValue; -import org.eclipse.core.databinding.observable.value.IValueChangeListener; -import org.eclipse.core.databinding.observable.value.ValueChangeEvent; -import org.eclipse.jface.databinding.swt.SWTObservables; -import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; -import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; -import org.eclipse.jface.databinding.viewers.ViewersObservables; -import org.eclipse.jface.dialogs.MessageDialog; -import org.eclipse.jface.viewers.ComboViewer; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.wizard.WizardPage; -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.events.SelectionListener; -import org.eclipse.swt.events.VerifyEvent; -import org.eclipse.swt.events.VerifyListener; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.widgets.Button; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Label; -import org.eclipse.swt.widgets.Text; - -import de.bmotionstudio.gef.editor.eventb.EventBHelper; -import de.bmotionstudio.gef.editor.eventb.MachineContentObject; -import de.bmotionstudio.gef.editor.eventb.MachineOperation; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.scheduler.ExecuteOperationByPredicate; -import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; -import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; - -public class WizardSchedulerExecuteOperationByPredicate extends SchedulerWizard { - - private class SchedulerExecuteOperationByPredicatePage extends WizardPage { - - private ComboViewer cbOperation; - - private Text txtPredicate; - - private Text txtMaxRandomOperations; - - private Label lbMaxRandomOperations; - - private Composite container; - - private Composite guardContainer; - - private Button checkboxRandomMode; - - public ComboViewer getCbOperation() { - return cbOperation; - } - - public Text getTxtMaxRandomOperations() { - return txtMaxRandomOperations; - } - - protected SchedulerExecuteOperationByPredicatePage(String pageName) { - super(pageName); - } - - public void createControl(final Composite parent) { - - final DataBindingContext dbc = new DataBindingContext(); - - container = new Composite(parent, SWT.NONE); - GridLayout gl = new GridLayout(2, false); - container.setLayout(gl); - - Label lb = new Label(container, SWT.NONE); - lb.setText("Select an operation: "); - - GridData gd = new GridData(GridData.FILL_HORIZONTAL); - gd.heightHint = 50; - - cbOperation = new ComboViewer(container, SWT.NONE); - cbOperation.getCombo().setLayoutData(new GridData(300, 50)); - - lb = new Label(container, SWT.NONE); - lb.setText("Predicate: "); - lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); - txtPredicate = new Text(container, SWT.BORDER | SWT.WRAP - | SWT.V_SCROLL); - txtPredicate.setLayoutData(gd); - - lb = new Label(container, SWT.NONE); - lb.setText("Random mode: "); - lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); - checkboxRandomMode = new Button(container, SWT.CHECK); - checkboxRandomMode.addSelectionListener(new SelectionListener() { - @Override - public void widgetSelected(SelectionEvent e) { - setRandomVisibility(checkboxRandomMode.getSelection()); - } - - @Override - public void widgetDefaultSelected(SelectionEvent e) { - } - }); - - lbMaxRandomOperations = new Label(container, SWT.NONE); - lbMaxRandomOperations.setText("Max Random Operations: "); - lbMaxRandomOperations.setLayoutData(new GridData( - GridData.VERTICAL_ALIGN_BEGINNING)); - txtMaxRandomOperations = new Text(container, SWT.BORDER); - txtMaxRandomOperations.setLayoutData(new GridData( - GridData.FILL_HORIZONTAL)); - txtMaxRandomOperations.addVerifyListener(new VerifyListener() { - @Override - public void verifyText(VerifyEvent e) { - String string = e.text; - char[] chars = new char[string.length()]; - string.getChars(0, chars.length, chars, 0); - for (int i = 0; i < chars.length; i++) { - if (!('0' <= chars[i] && chars[i] <= '9')) { - e.doit = false; - return; - } - } - } - }); - setRandomVisibility(((ExecuteOperationByPredicate) getScheduler()) - .getPredicateOperation().isRandom()); - - initBindings(dbc); - - IStructuredSelection structuredSelection = (IStructuredSelection) cbOperation - .getSelection(); - - if (!structuredSelection.isEmpty()) { - createGuardContainer((MachineOperation) structuredSelection - .getFirstElement()); - } - - setControl(container); - - } - - private void setRandomVisibility(boolean b) { - if (lbMaxRandomOperations == null || txtMaxRandomOperations == null) - return; - lbMaxRandomOperations.setVisible(b); - txtMaxRandomOperations.setVisible(b); - } - - private void initBindings(DataBindingContext dbc) { - - // MachineContentList operationList = BMotionEditorPlugin - // .getActiveEditor().getVisualization().getOperationList(); - // operationList.getMap().remove("INITIALISATION"); - - ObservableListContentProvider cbOpContentProvider = new ObservableListContentProvider(); - cbOperation.setContentProvider(cbOpContentProvider); - IObservableMap[] attributeMaps = BeansObservables.observeMaps( - cbOpContentProvider.getKnownElements(), - MachineContentObject.class, new String[] { "label" }); - cbOperation.setLabelProvider(new ObservableMapLabelProvider( - attributeMaps)); - cbOperation.setInput(new WritableList(EventBHelper - .getOperations(getBControl().getVisualization()), - MachineOperation.class)); - cbOperation.getCombo().setFont( - new Font(Display.getDefault(), new FontData("Arial", 10, - SWT.NONE))); - - final IObservableValue observeSelection = ViewersObservables - .observeSingleSelection(cbOperation); - - dbc.bindValue(SWTObservables.observeSelection(cbOperation - .getCombo()), BeansObservables.observeValue( - ((ExecuteOperationByPredicate) getScheduler()) - .getPredicateOperation(), "operationName"), null, - null); - - dbc.bindValue(SWTObservables.observeText(txtPredicate, SWT.Modify), - BeansObservables.observeValue( - ((ExecuteOperationByPredicate) getScheduler()) - .getPredicateOperation(), "predicate")); - - observeSelection.addValueChangeListener(new IValueChangeListener() { - public void handleValueChange(ValueChangeEvent event) { - Object sel = event.getObservableValue().getValue(); - createGuardContainer((MachineOperation) sel); - } - }); - - dbc.bindValue(SWTObservables.observeSelection(checkboxRandomMode), - BeansObservables.observeValue( - ((ExecuteOperationByPredicate) getScheduler()) - .getPredicateOperation(), "random")); - - dbc.bindValue(SWTObservables.observeText(txtMaxRandomOperations, - SWT.Modify), BeansObservables.observeValue( - ((ExecuteOperationByPredicate) getScheduler()) - .getPredicateOperation(), "maxrandom")); - - } - - private void createGuardContainer(MachineOperation op) { - - if (guardContainer != null) - guardContainer.dispose(); - - final StringBuilder allGuardString = new StringBuilder(); - - if (op != null) { - - GridData gd = new GridData(GridData.FILL_HORIZONTAL); - gd.horizontalSpan = 2; - - GridLayout gl = new GridLayout(2, false); - - guardContainer = new Composite(container, SWT.NONE); - guardContainer.setLayoutData(gd); - guardContainer.setLayout(gl); - - for (String guard : op.getGuards()) { - - if (allGuardString.length() == 0) - allGuardString.append(guard); - else - allGuardString.append(" & " + guard); - - Label lb = new Label(guardContainer, SWT.NONE); - lb.setText("Guard: "); - lb.setLayoutData(new GridData(100, 15)); - - final Text txt = new Text(guardContainer, SWT.BORDER - | SWT.READ_ONLY); - txt.setText(guard); - txt.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); - // txt.setFont(JFaceResources.getFontRegistry().get( - // BMotionStudioConstants.RODIN_FONT_KEY)); - - } - - container.layout(); - - } - - } - - } - - public WizardSchedulerExecuteOperationByPredicate(BControl bcontrol, - SchedulerEvent scheduler) { - super(bcontrol, scheduler); - addPage(new SchedulerExecuteOperationByPredicatePage( - "SchedulerExecuteOperationByPredicatePage")); - } - - @Override - protected Boolean prepareToFinish() { - - SchedulerExecuteOperationByPredicatePage page = (SchedulerExecuteOperationByPredicatePage) getPage("SchedulerExecuteOperationByPredicatePage"); - - String errorStr = ""; - - if (((ExecuteOperationByPredicate) getScheduler()) - .getPredicateOperation().isRandom() - && !(Integer - .valueOf(page.getTxtMaxRandomOperations().getText()) > 0)) - errorStr += "Max Random Operations must be greater than 0.\n"; - - if (page.getCbOperation().getCombo().getSelectionIndex() == -1) - errorStr += "Please select an operation.\n"; - - if (errorStr.length() > 0) { - MessageDialog.openError(Display.getDefault().getActiveShell(), - "An Error occured", errorStr); - return false; - } - - // PredicateOperation predicateOperation = - // ((ExecuteOperationByPredicate) getScheduler()) - // .getPredicateOperation(); - // - // Observer observer = getBControl().getObserver( - // ListenOperationByPredicate.ID); - // ListenOperationByPredicate listenObserver; - // - // if (observer != null) { - // listenObserver = (ListenOperationByPredicate) observer; - // listenObserver - // .removePredicateOperationByUniqueID(predicateOperation - // .getUniqueID()); - // } else { - // listenObserver = new ListenOperationByPredicate(); - // getBControl().addObserver(listenObserver); - // } - // - // try { - // listenObserver.addPredicateOperation(predicateOperation.clone()); - // } catch (CloneNotSupportedException e) { - // e.printStackTrace(); - // } - - return true; - - } - - @Override - public Point getSize() { - return new Point(600, 600); - } - -} +/** + * (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.bmotionstudio.gef.editor.scheduler.wizard; + +import org.eclipse.core.databinding.DataBindingContext; +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.core.databinding.observable.map.IObservableMap; +import org.eclipse.core.databinding.observable.value.IObservableValue; +import org.eclipse.core.databinding.observable.value.IValueChangeListener; +import org.eclipse.core.databinding.observable.value.ValueChangeEvent; +import org.eclipse.jface.databinding.swt.SWTObservables; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; +import org.eclipse.jface.databinding.viewers.ViewersObservables; +import org.eclipse.jface.dialogs.MessageDialog; +import org.eclipse.jface.viewers.ComboViewer; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.events.SelectionListener; +import org.eclipse.swt.events.VerifyEvent; +import org.eclipse.swt.events.VerifyListener; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Label; +import org.eclipse.swt.widgets.Text; + +import de.bmotionstudio.gef.editor.eventb.EventBHelper; +import de.bmotionstudio.gef.editor.eventb.MachineContentObject; +import de.bmotionstudio.gef.editor.eventb.MachineOperation; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.scheduler.ExecuteOperationByPredicate; +import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; +import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; + +public class WizardExecuteOperationByPredicate extends SchedulerWizard { + + private class SchedulerExecuteOperationByPredicatePage extends WizardPage { + + private ComboViewer cbOperation; + + private Text txtPredicate; + + private Text txtMaxRandomOperations; + + private Label lbMaxRandomOperations; + + private Composite container; + + private Composite guardContainer; + + private Button checkboxRandomMode; + + public ComboViewer getCbOperation() { + return cbOperation; + } + + public Text getTxtMaxRandomOperations() { + return txtMaxRandomOperations; + } + + protected SchedulerExecuteOperationByPredicatePage(String pageName) { + super(pageName); + } + + public void createControl(final Composite parent) { + + final DataBindingContext dbc = new DataBindingContext(); + + container = new Composite(parent, SWT.NONE); + GridLayout gl = new GridLayout(2, false); + container.setLayout(gl); + + Label lb = new Label(container, SWT.NONE); + lb.setText("Select an operation: "); + + GridData gd = new GridData(GridData.FILL_HORIZONTAL); + gd.heightHint = 50; + + cbOperation = new ComboViewer(container, SWT.NONE); + cbOperation.getCombo().setLayoutData(new GridData(300, 50)); + + lb = new Label(container, SWT.NONE); + lb.setText("Predicate: "); + lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); + txtPredicate = new Text(container, SWT.BORDER | SWT.WRAP + | SWT.V_SCROLL); + txtPredicate.setLayoutData(gd); + + lb = new Label(container, SWT.NONE); + lb.setText("Random mode: "); + lb.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING)); + checkboxRandomMode = new Button(container, SWT.CHECK); + checkboxRandomMode.addSelectionListener(new SelectionListener() { + @Override + public void widgetSelected(SelectionEvent e) { + setRandomVisibility(checkboxRandomMode.getSelection()); + } + + @Override + public void widgetDefaultSelected(SelectionEvent e) { + } + }); + + lbMaxRandomOperations = new Label(container, SWT.NONE); + lbMaxRandomOperations.setText("Max Random Operations: "); + lbMaxRandomOperations.setLayoutData(new GridData( + GridData.VERTICAL_ALIGN_BEGINNING)); + txtMaxRandomOperations = new Text(container, SWT.BORDER); + txtMaxRandomOperations.setLayoutData(new GridData( + GridData.FILL_HORIZONTAL)); + txtMaxRandomOperations.addVerifyListener(new VerifyListener() { + @Override + public void verifyText(VerifyEvent e) { + String string = e.text; + char[] chars = new char[string.length()]; + string.getChars(0, chars.length, chars, 0); + for (int i = 0; i < chars.length; i++) { + if (!('0' <= chars[i] && chars[i] <= '9')) { + e.doit = false; + return; + } + } + } + }); + setRandomVisibility(((ExecuteOperationByPredicate) getScheduler()) + .getPredicateOperation().isRandom()); + + initBindings(dbc); + + IStructuredSelection structuredSelection = (IStructuredSelection) cbOperation + .getSelection(); + + if (!structuredSelection.isEmpty()) { + createGuardContainer((MachineOperation) structuredSelection + .getFirstElement()); + } + + setControl(container); + + } + + private void setRandomVisibility(boolean b) { + if (lbMaxRandomOperations == null || txtMaxRandomOperations == null) + return; + lbMaxRandomOperations.setVisible(b); + txtMaxRandomOperations.setVisible(b); + } + + private void initBindings(DataBindingContext dbc) { + + // MachineContentList operationList = BMotionEditorPlugin + // .getActiveEditor().getVisualization().getOperationList(); + // operationList.getMap().remove("INITIALISATION"); + + ObservableListContentProvider cbOpContentProvider = new ObservableListContentProvider(); + cbOperation.setContentProvider(cbOpContentProvider); + IObservableMap[] attributeMaps = BeansObservables.observeMaps( + cbOpContentProvider.getKnownElements(), + MachineContentObject.class, new String[] { "label" }); + cbOperation.setLabelProvider(new ObservableMapLabelProvider( + attributeMaps)); + cbOperation.setInput(new WritableList(EventBHelper + .getOperations(getBControl().getVisualization()), + MachineOperation.class)); + cbOperation.getCombo().setFont( + new Font(Display.getDefault(), new FontData("Arial", 10, + SWT.NONE))); + + final IObservableValue observeSelection = ViewersObservables + .observeSingleSelection(cbOperation); + + dbc.bindValue(SWTObservables.observeSelection(cbOperation + .getCombo()), BeansObservables.observeValue( + ((ExecuteOperationByPredicate) getScheduler()) + .getPredicateOperation(), "operationName"), null, + null); + + dbc.bindValue(SWTObservables.observeText(txtPredicate, SWT.Modify), + BeansObservables.observeValue( + ((ExecuteOperationByPredicate) getScheduler()) + .getPredicateOperation(), "predicate")); + + observeSelection.addValueChangeListener(new IValueChangeListener() { + public void handleValueChange(ValueChangeEvent event) { + Object sel = event.getObservableValue().getValue(); + createGuardContainer((MachineOperation) sel); + } + }); + + dbc.bindValue(SWTObservables.observeSelection(checkboxRandomMode), + BeansObservables.observeValue( + ((ExecuteOperationByPredicate) getScheduler()) + .getPredicateOperation(), "random")); + + dbc.bindValue(SWTObservables.observeText(txtMaxRandomOperations, + SWT.Modify), BeansObservables.observeValue( + ((ExecuteOperationByPredicate) getScheduler()) + .getPredicateOperation(), "maxrandom")); + + } + + private void createGuardContainer(MachineOperation op) { + + if (guardContainer != null) + guardContainer.dispose(); + + final StringBuilder allGuardString = new StringBuilder(); + + if (op != null) { + + GridData gd = new GridData(GridData.FILL_HORIZONTAL); + gd.horizontalSpan = 2; + + GridLayout gl = new GridLayout(2, false); + + guardContainer = new Composite(container, SWT.NONE); + guardContainer.setLayoutData(gd); + guardContainer.setLayout(gl); + + for (String guard : op.getGuards()) { + + if (allGuardString.length() == 0) + allGuardString.append(guard); + else + allGuardString.append(" & " + guard); + + Label lb = new Label(guardContainer, SWT.NONE); + lb.setText("Guard: "); + lb.setLayoutData(new GridData(100, 15)); + + final Text txt = new Text(guardContainer, SWT.BORDER + | SWT.READ_ONLY); + txt.setText(guard); + txt.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); + // txt.setFont(JFaceResources.getFontRegistry().get( + // BMotionStudioConstants.RODIN_FONT_KEY)); + + } + + container.layout(); + + } + + } + + } + + public WizardExecuteOperationByPredicate(BControl bcontrol, + SchedulerEvent scheduler) { + super(bcontrol, scheduler); + addPage(new SchedulerExecuteOperationByPredicatePage( + "SchedulerExecuteOperationByPredicatePage")); + } + + @Override + protected Boolean prepareToFinish() { + + SchedulerExecuteOperationByPredicatePage page = (SchedulerExecuteOperationByPredicatePage) getPage("SchedulerExecuteOperationByPredicatePage"); + + String errorStr = ""; + + if (((ExecuteOperationByPredicate) getScheduler()) + .getPredicateOperation().isRandom() + && !(Integer + .valueOf(page.getTxtMaxRandomOperations().getText()) > 0)) + errorStr += "Max Random Operations must be greater than 0.\n"; + + if (page.getCbOperation().getCombo().getSelectionIndex() == -1) + errorStr += "Please select an operation.\n"; + + if (errorStr.length() > 0) { + MessageDialog.openError(Display.getDefault().getActiveShell(), + "An Error occured", errorStr); + return false; + } + + // PredicateOperation predicateOperation = + // ((ExecuteOperationByPredicate) getScheduler()) + // .getPredicateOperation(); + // + // Observer observer = getBControl().getObserver( + // ListenOperationByPredicate.ID); + // ListenOperationByPredicate listenObserver; + // + // if (observer != null) { + // listenObserver = (ListenOperationByPredicate) observer; + // listenObserver + // .removePredicateOperationByUniqueID(predicateOperation + // .getUniqueID()); + // } else { + // listenObserver = new ListenOperationByPredicate(); + // getBControl().addObserver(listenObserver); + // } + // + // try { + // listenObserver.addPredicateOperation(predicateOperation.clone()); + // } catch (CloneNotSupportedException e) { + // e.printStackTrace(); + // } + + return true; + + } + + @Override + public Point getSize() { + return new Point(600, 600); + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicateMulti.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicateMulti.java index d301e8ccb815cd2864f76f75cad690b1325d0cd5..ef33b42a06fed9594556b7b95ad8a97525dd9c09 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicateMulti.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteOperationByPredicateMulti.java @@ -5,19 +5,14 @@ * */ package de.bmotionstudio.gef.editor.scheduler.wizard; -import java.util.ArrayList; -import java.util.List; - import org.eclipse.core.databinding.DataBindingContext; import org.eclipse.core.databinding.beans.BeansObservables; -import org.eclipse.core.databinding.observable.list.ComputedList; import org.eclipse.core.databinding.observable.list.WritableList; import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.viewers.CellEditor; import org.eclipse.jface.viewers.ColumnViewer; -import org.eclipse.jface.viewers.ComboBoxViewerCellEditor; import org.eclipse.jface.viewers.EditingSupport; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.TableViewer; @@ -26,29 +21,26 @@ import org.eclipse.jface.wizard.WizardPage; import org.eclipse.swt.SWT; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.layout.RowLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Display; +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; import de.bmotionstudio.gef.editor.BMotionStudioImage; import de.bmotionstudio.gef.editor.BindingObject; import de.bmotionstudio.gef.editor.EditorImageRegistry; +import de.bmotionstudio.gef.editor.edit.OperationValueEditingSupport; import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; -import de.bmotionstudio.gef.editor.eventb.EventBHelper; -import de.bmotionstudio.gef.editor.eventb.MachineContentObject; -import de.bmotionstudio.gef.editor.eventb.MachineOperation; import de.bmotionstudio.gef.editor.model.BControl; import de.bmotionstudio.gef.editor.property.IntegerCellEditor; import de.bmotionstudio.gef.editor.scheduler.ExecuteOperationByPredicateMulti; import de.bmotionstudio.gef.editor.scheduler.PredicateOperation; import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; /** * @author Lukas Ladenberger @@ -73,16 +65,10 @@ public class WizardExecuteOperationByPredicateMulti extends SchedulerWizard { setControl(container); - tableViewer = new TableViewer(container, SWT.BORDER - | SWT.FULL_SELECTION); - tableViewer.getTable().setLinesVisible(true); - tableViewer.getTable().setHeaderVisible(true); - tableViewer.getTable().setLayoutData( - new GridData(GridData.FILL_BOTH)); - tableViewer.getTable().setFont( - new Font(Display.getDefault(), new FontData("Arial", 10, - SWT.NONE))); - + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( + container, PredicateOperation.class, + ((BMotionAbstractWizard) getWizard()).getName()); + TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE); column.getColumn().setText("Execute Rule"); @@ -94,8 +80,8 @@ public class WizardExecuteOperationByPredicateMulti extends SchedulerWizard { column = new TableViewerColumn(tableViewer, SWT.NONE); column.getColumn().setText("Operation"); column.getColumn().setWidth(150); - column.setEditingSupport(new OperationValueEditing(tableViewer, - getBControl())); + column.setEditingSupport(new OperationValueEditingSupport( + tableViewer, getBControl())); column = new TableViewerColumn(tableViewer, SWT.NONE); column.getColumn().setText("Parameter"); @@ -243,59 +229,6 @@ public class WizardExecuteOperationByPredicateMulti extends SchedulerWizard { } - private static class OperationValueEditing extends EditingSupport { - - private ComboBoxViewerCellEditor cellEditor = null; - - private final BControl control; - - public OperationValueEditing(final TableViewer cv, - final BControl control) { - super(cv); - this.control = control; - } - - @Override - protected boolean canEdit(final Object element) { - return true; - } - - @Override - protected Object getValue(final Object element) { - return ((PredicateOperation) element).getOperationName(); - } - - @Override - protected void setValue(final Object element, final Object value) { - if (value != null) { - ((PredicateOperation) element).setOperationName(value - .toString()); - } - } - - @Override - protected CellEditor getCellEditor(final Object element) { - if (cellEditor == null) { - cellEditor = new ComboBoxViewerCellEditor( - (Composite) getViewer().getControl(), SWT.READ_ONLY); - cellEditor - .setContentProvider(new ObservableListContentProvider()); - cellEditor.setInput(new ComputedList() { - @Override - protected List<String> calculate() { - ArrayList<String> tmpList = new ArrayList<String>(); - for (MachineContentObject op : EventBHelper - .getOperations(control.getVisualization())) { - tmpList.add(((MachineOperation) op).getLabel()); - } - return tmpList; - } - }); - } - return cellEditor; - } - } - // private class ObserverLabelProvider extends ObservableMapLabelProvider // implements ITableLabelProvider, ITableColorProvider, // ITableFontProvider { diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteAnimationScript.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteScheduler.java similarity index 90% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteAnimationScript.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteScheduler.java index 92a44580afcb5fd04e30a748da6e615098b084c7..87d3d3f1dee27138e2b14e6ee586fb386e5576a7 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteAnimationScript.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/scheduler/wizard/WizardExecuteScheduler.java @@ -1,226 +1,219 @@ -/** - * (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.bmotionstudio.gef.editor.scheduler.wizard; - -import org.eclipse.core.databinding.DataBindingContext; -import org.eclipse.core.databinding.beans.BeansObservables; -import org.eclipse.core.databinding.observable.list.WritableList; -import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; -import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; -import org.eclipse.jface.dialogs.Dialog; -import org.eclipse.jface.viewers.CellEditor; -import org.eclipse.jface.viewers.ColumnViewer; -import org.eclipse.jface.viewers.DialogCellEditor; -import org.eclipse.jface.viewers.EditingSupport; -import org.eclipse.jface.viewers.IStructuredSelection; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.viewers.TableViewerColumn; -import org.eclipse.jface.wizard.WizardPage; -import org.eclipse.swt.SWT; -import org.eclipse.swt.events.SelectionAdapter; -import org.eclipse.swt.events.SelectionEvent; -import org.eclipse.swt.graphics.Font; -import org.eclipse.swt.graphics.FontData; -import org.eclipse.swt.graphics.Image; -import org.eclipse.swt.graphics.Point; -import org.eclipse.swt.layout.GridData; -import org.eclipse.swt.layout.GridLayout; -import org.eclipse.swt.layout.RowLayout; -import org.eclipse.swt.widgets.Button; -import org.eclipse.swt.widgets.Composite; -import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Display; -import org.eclipse.ui.PlatformUI; - -import de.bmotionstudio.gef.editor.BMotionStudioImage; -import de.bmotionstudio.gef.editor.EditorImageRegistry; -import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; -import de.bmotionstudio.gef.editor.model.BControl; -import de.bmotionstudio.gef.editor.scheduler.AnimationScriptObject; -import de.bmotionstudio.gef.editor.scheduler.ExecuteAnimationScript; -import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; -import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; - -public class WizardExecuteAnimationScript extends SchedulerWizard { - - private class SchedulerPage extends WizardPage { - - private TableViewer tableViewer; - - protected SchedulerPage(String pageName) { - super(pageName); - } - - public void createControl(final Composite parent) { - - DataBindingContext dbc = new DataBindingContext(); - - Composite container = new Composite(parent, SWT.NONE); - container.setLayout(new GridLayout(1, true)); - - setControl(container); - - tableViewer = new TableViewer(container, SWT.BORDER - | SWT.FULL_SELECTION); - tableViewer.getTable().setLinesVisible(true); - tableViewer.getTable().setHeaderVisible(true); - tableViewer.getTable().setLayoutData( - new GridData(GridData.FILL_BOTH)); - tableViewer.getTable().setFont( - new Font(Display.getDefault(), new FontData("Arial", 10, - SWT.NONE))); - - TableViewerColumn column = new TableViewerColumn(tableViewer, - SWT.NONE); - column.getColumn().setText("Predicate"); - column.getColumn().setWidth(225); - column.setEditingSupport(new PredicateEditingSupport(tableViewer, - dbc, "predicate", getBControl().getVisualization(), - getShell())); - - column = new TableViewerColumn(tableViewer, SWT.NONE); - column.getColumn().setText("Edit"); - column.getColumn().setWidth(225); - column.setEditingSupport(new AnimationScriptEditingSupport( - tableViewer)); - - ObservableListContentProvider contentProvider = new ObservableListContentProvider(); - tableViewer.setContentProvider(contentProvider); - - tableViewer.setLabelProvider(new ObservableMapLabelProvider( - BeansObservables.observeMaps( - contentProvider.getKnownElements(), - new String[] { "predicate" })) { - - @Override - public String getColumnText(Object element, int columnIndex) { - if (columnIndex == 1) { - return "Edit Scheduler"; - } - return super.getColumnText(element, columnIndex); - } - - @Override - public Image getColumnImage(Object element, int columnIndex) { - return null; - } - - }); - - final WritableList input = new WritableList( - ((ExecuteAnimationScript) getScheduler()).getList(), - AnimationScriptObject.class); - tableViewer.setInput(input); - - Composite comp = new Composite(container, SWT.NONE); - comp.setLayout(new RowLayout()); - comp.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END)); - - Button btRemove = new Button(comp, SWT.PUSH); - btRemove.setText("Remove"); - btRemove.setImage(BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_DELETE)); - btRemove.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(SelectionEvent e) { - if (tableViewer.getSelection().isEmpty()) { - return; - } - AnimationScriptObject obj = (AnimationScriptObject) ((IStructuredSelection) tableViewer - .getSelection()).getFirstElement(); - input.remove(obj); - } - }); - - Button btAdd = new Button(comp, SWT.PUSH); - btAdd.setText("Add"); - btAdd.setImage(BMotionStudioImage - .getImage(EditorImageRegistry.IMG_ICON_ADD)); - btAdd.addSelectionListener(new SelectionAdapter() { - @Override - public void widgetSelected(SelectionEvent e) { - AnimationScriptObject obj = new AnimationScriptObject(""); - input.add(obj); - } - }); - - } - } - - public WizardExecuteAnimationScript(BControl bcontrol, - SchedulerEvent scheduler) { - super(bcontrol, scheduler); - addPage(new SchedulerPage("SchedulerPage")); - } - - @Override - protected Boolean prepareToFinish() { - return true; - } - - @Override - public boolean performCancel() { - return true; - } - - @Override - public Point getSize() { - return new Point(600, 500); - } - - private class AnimationScriptEditingSupport extends EditingSupport { - - public AnimationScriptEditingSupport(ColumnViewer viewer) { - super(viewer); - } - - @Override - protected boolean canEdit(Object element) { - return true; - } - - @Override - protected CellEditor getCellEditor(Object element) { - return new AnimationScriptDialogCellEditor((Composite) getViewer() - .getControl(), (AnimationScriptObject) element); - } - - @Override - protected Object getValue(Object element) { - return "Edit Scheduler"; - } - - @Override - protected void setValue(Object element, Object value) { - } - - } - - private class AnimationScriptDialogCellEditor extends DialogCellEditor { - - private AnimationScriptObject animObj; - - public AnimationScriptDialogCellEditor(Composite parent, - AnimationScriptObject animObj) { - super(parent); - this.animObj = animObj; - } - - @Override - protected Object openDialogBox(Control cellEditorWindow) { - AnimationScriptObjectDialog dialog = new AnimationScriptObjectDialog( - PlatformUI.getWorkbench().getActiveWorkbenchWindow() - .getShell(), getBControl(), animObj); - if (dialog.open() == Dialog.OK) { - return getValue(); - } - return null; - } - - } - -} +/** + * (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.bmotionstudio.gef.editor.scheduler.wizard; + +import org.eclipse.core.databinding.DataBindingContext; +import org.eclipse.core.databinding.beans.BeansObservables; +import org.eclipse.core.databinding.observable.list.WritableList; +import org.eclipse.jface.databinding.viewers.ObservableListContentProvider; +import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider; +import org.eclipse.jface.dialogs.Dialog; +import org.eclipse.jface.viewers.CellEditor; +import org.eclipse.jface.viewers.ColumnViewer; +import org.eclipse.jface.viewers.DialogCellEditor; +import org.eclipse.jface.viewers.EditingSupport; +import org.eclipse.jface.viewers.IStructuredSelection; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.TableViewerColumn; +import org.eclipse.jface.wizard.WizardPage; +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.SelectionAdapter; +import org.eclipse.swt.events.SelectionEvent; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.GridData; +import org.eclipse.swt.layout.GridLayout; +import org.eclipse.swt.layout.RowLayout; +import org.eclipse.swt.widgets.Button; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.ui.PlatformUI; + +import de.bmotionstudio.gef.editor.BMotionAbstractWizard; +import de.bmotionstudio.gef.editor.BMotionStudioImage; +import de.bmotionstudio.gef.editor.EditorImageRegistry; +import de.bmotionstudio.gef.editor.edit.PredicateEditingSupport; +import de.bmotionstudio.gef.editor.model.BControl; +import de.bmotionstudio.gef.editor.scheduler.AnimationScriptObject; +import de.bmotionstudio.gef.editor.scheduler.ExecuteAnimationScript; +import de.bmotionstudio.gef.editor.scheduler.SchedulerEvent; +import de.bmotionstudio.gef.editor.scheduler.SchedulerWizard; +import de.bmotionstudio.gef.editor.util.BMotionWizardUtil; + +public class WizardExecuteScheduler extends SchedulerWizard { + + private class SchedulerPage extends WizardPage { + + private TableViewer tableViewer; + + protected SchedulerPage(String pageName) { + super(pageName); + } + + public void createControl(final Composite parent) { + + DataBindingContext dbc = new DataBindingContext(); + + Composite container = new Composite(parent, SWT.NONE); + container.setLayout(new GridLayout(1, true)); + + setControl(container); + + tableViewer = BMotionWizardUtil.createBMotionWizardTableViewer( + container, AnimationScriptObject.class, + ((BMotionAbstractWizard) getWizard()).getName()); + + TableViewerColumn column = new TableViewerColumn(tableViewer, + SWT.NONE); + column.getColumn().setText("Predicate"); + column.getColumn().setWidth(225); + column.setEditingSupport(new PredicateEditingSupport(tableViewer, + dbc, "predicate", getBControl().getVisualization(), + getShell())); + + column = new TableViewerColumn(tableViewer, SWT.NONE); + column.getColumn().setText("Edit"); + column.getColumn().setWidth(225); + column.setEditingSupport(new AnimationScriptEditingSupport( + tableViewer)); + + ObservableListContentProvider contentProvider = new ObservableListContentProvider(); + tableViewer.setContentProvider(contentProvider); + + tableViewer.setLabelProvider(new ObservableMapLabelProvider( + BeansObservables.observeMaps( + contentProvider.getKnownElements(), + new String[] { "predicate" })) { + + @Override + public String getColumnText(Object element, int columnIndex) { + if (columnIndex == 1) { + return "Edit Scheduler"; + } + return super.getColumnText(element, columnIndex); + } + + @Override + public Image getColumnImage(Object element, int columnIndex) { + return null; + } + + }); + + final WritableList input = new WritableList( + ((ExecuteAnimationScript) getScheduler()).getList(), + AnimationScriptObject.class); + tableViewer.setInput(input); + + Composite comp = new Composite(container, SWT.NONE); + comp.setLayout(new RowLayout()); + comp.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_END)); + + Button btRemove = new Button(comp, SWT.PUSH); + btRemove.setText("Remove"); + btRemove.setImage(BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_DELETE)); + btRemove.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(SelectionEvent e) { + if (tableViewer.getSelection().isEmpty()) { + return; + } + AnimationScriptObject obj = (AnimationScriptObject) ((IStructuredSelection) tableViewer + .getSelection()).getFirstElement(); + input.remove(obj); + } + }); + + Button btAdd = new Button(comp, SWT.PUSH); + btAdd.setText("Add"); + btAdd.setImage(BMotionStudioImage + .getImage(EditorImageRegistry.IMG_ICON_ADD)); + btAdd.addSelectionListener(new SelectionAdapter() { + @Override + public void widgetSelected(SelectionEvent e) { + AnimationScriptObject obj = new AnimationScriptObject(""); + input.add(obj); + } + }); + + } + } + + public WizardExecuteScheduler(BControl bcontrol, + SchedulerEvent scheduler) { + super(bcontrol, scheduler); + addPage(new SchedulerPage("SchedulerPage")); + } + + @Override + protected Boolean prepareToFinish() { + return true; + } + + @Override + public boolean performCancel() { + return true; + } + + @Override + public Point getSize() { + return new Point(600, 500); + } + + private class AnimationScriptEditingSupport extends EditingSupport { + + public AnimationScriptEditingSupport(ColumnViewer viewer) { + super(viewer); + } + + @Override + protected boolean canEdit(Object element) { + return true; + } + + @Override + protected CellEditor getCellEditor(Object element) { + return new AnimationScriptDialogCellEditor((Composite) getViewer() + .getControl(), (AnimationScriptObject) element); + } + + @Override + protected Object getValue(Object element) { + return "Edit Scheduler"; + } + + @Override + protected void setValue(Object element, Object value) { + } + + } + + private class AnimationScriptDialogCellEditor extends DialogCellEditor { + + private AnimationScriptObject animObj; + + public AnimationScriptDialogCellEditor(Composite parent, + AnimationScriptObject animObj) { + super(parent); + this.animObj = animObj; + } + + @Override + protected Object openDialogBox(Control cellEditorWindow) { + SchedulerObjectDialog dialog = new SchedulerObjectDialog( + PlatformUI.getWorkbench().getActiveWorkbenchWindow() + .getShell(), getBControl(), animObj); + if (dialog.open() == Dialog.OK) { + return getValue(); + } + return null; + } + + } + +} diff --git a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/util/WizardObserverUtil.java b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/util/BMotionWizardUtil.java similarity index 79% rename from de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/util/WizardObserverUtil.java rename to de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/util/BMotionWizardUtil.java index 7c6f5c0f6f763e37b322cd1df6fbda0375ce10c7..b2c4fa4123b2b707b4fe0898e2a2909ecbb8c488 100644 --- a/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/util/WizardObserverUtil.java +++ b/de.bmotionstudio.gef.editor/src/de/bmotionstudio/gef/editor/util/BMotionWizardUtil.java @@ -18,14 +18,13 @@ import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.TableItem; import de.bmotionstudio.gef.editor.BMotionStudioSWTConstants; +import de.bmotionstudio.gef.editor.action.BMotionWizardAddItemAction; +import de.bmotionstudio.gef.editor.action.BMotionWizardDeleteItemsAction; import de.bmotionstudio.gef.editor.library.AttributeTransfer; -import de.bmotionstudio.gef.editor.observer.ObserverWizard; -import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverAddItemAction; -import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverDeleteItemsAction; import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverDragListener; import de.bmotionstudio.gef.editor.observer.wizard.WizardObserverDropListener; -public class WizardObserverUtil { +public class BMotionWizardUtil { public static boolean isEditElement(ColumnViewer viewer) { Object data = viewer.getData("editElement"); @@ -34,8 +33,8 @@ public class WizardObserverUtil { return false; } - public static TableViewer createObserverWizardTableViewer(Composite parent, - Class<?> itemClass, final ObserverWizard observerWizard) { + public static TableViewer createBMotionWizardTableViewer(Composite parent, + Class<?> itemClass, final String wizardName) { final TableViewer tableViewer = new TableViewer(parent, SWT.BORDER | SWT.FULL_SELECTION | SWT.MULTI); @@ -47,17 +46,17 @@ public class WizardObserverUtil { int operations = DND.DROP_COPY | DND.DROP_MOVE; Transfer[] transferTypes = new Transfer[] { AttributeTransfer .getInstance() }; + tableViewer.addDropSupport(operations, transferTypes, - new WizardObserverDropListener(tableViewer, observerWizard - .getObserver().getName())); + new WizardObserverDropListener(tableViewer, wizardName)); tableViewer.addDragSupport(operations, transferTypes, new WizardObserverDragListener(tableViewer)); MenuManager manager = new MenuManager(); tableViewer.getControl().setMenu( manager.createContextMenu(tableViewer.getControl())); - manager.add(new WizardObserverDeleteItemsAction(tableViewer)); - manager.add(new WizardObserverAddItemAction(tableViewer, itemClass)); + manager.add(new BMotionWizardDeleteItemsAction(tableViewer)); + manager.add(new BMotionWizardAddItemAction(tableViewer, itemClass)); tableViewer.getTable().addListener(SWT.MouseDown, new Listener() { public void handleEvent(Event event) { diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java index f416a69eca11c1766aef1ef49d587009be11a53b..ab9082e164d793cd4311837eb1f9a89db2dece6f 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExample.java @@ -20,75 +20,95 @@ import de.prob.prolog.term.PrologTerm; * @author Andriy Tolstoy * */ -public final class CounterExample { +public class CounterExample { private final static PrologTerm NONE = new CompoundPrologTerm("none"); private final CounterExampleProposition propositionRoot; private final List<CounterExampleProposition> propositions = new ArrayList<CounterExampleProposition>(); private final List<CounterExampleState> states = new ArrayList<CounterExampleState>(); private final int loopEntry; - private List<ArrayList<Boolean>> predicateValues; private final List<Operation> initPath; - private final ListPrologTerm atomics; - private final ListPrologTerm example; private final PathType pathType; + private final int ceSize; // the length of the counterexample (number of + // states without the initialisation) + + protected CounterExample(CounterExampleProposition propositionRoot, + int loopEntry, List<Operation> initPath, PathType pathType, + int ceSize) { + super(); + this.propositionRoot = propositionRoot; + this.loopEntry = loopEntry; + this.initPath = initPath; + this.pathType = pathType; + this.ceSize = ceSize; + } public CounterExample(final Result modelCheckingResult) { - atomics = modelCheckingResult.getAtomics(); - example = modelCheckingResult.getCounterexample(); loopEntry = modelCheckingResult.getLoopEntry(); pathType = modelCheckingResult.getPathType(); initPath = Collections.unmodifiableList(Arrays .asList(modelCheckingResult.getInitPathOps())); + ceSize = modelCheckingResult.getCounterexample().size(); - createStates(example); + final List<ArrayList<Boolean>> predicateValues = createStates(modelCheckingResult + .getCounterexample()); - propositionRoot = createExample(modelCheckingResult.getStructure()); + final String[] atomicFormulaNames = createAtomicNames(modelCheckingResult); + propositionRoot = createExample(modelCheckingResult.getStructure(), + atomicFormulaNames, predicateValues); propositionRoot.setVisible(true); Collections.reverse(propositions); } - private void createStates(final ListPrologTerm example) { - // final boolean isLoopType = pathType == PathType.INFINITE; - int index = 0; + private String[] createAtomicNames(final Result modelCheckingResult) { + String[] res = new String[modelCheckingResult.getAtomics().size()]; + int i = 0; + for (final PrologTerm term : modelCheckingResult.getAtomics()) { + res[i] = PrologTerm.atomicString(((CompoundPrologTerm) term) + .getArgument(1)); + } + return res; + } + + private List<ArrayList<Boolean>> createStates(final ListPrologTerm example) { + List<ArrayList<Boolean>> predicateValues = new ArrayList<ArrayList<Boolean>>(); + + for (int i = 0; i < example.size(); i++) { + predicateValues.add(new ArrayList<Boolean>()); + } + int index = 0; for (PrologTerm exampleElement : example) { CompoundPrologTerm state = (CompoundPrologTerm) exampleElement; - int stateId = ((IntegerPrologTerm) state.getArgument(1)).getValue() - .intValue(); + final PrologTerm stateId = state.getArgument(1); final ListPrologTerm values = ((ListPrologTerm) state .getArgument(2)); final CompoundPrologTerm operationTerm = (CompoundPrologTerm) state .getArgument(3); - if (predicateValues == null) { - predicateValues = new ArrayList<ArrayList<Boolean>>(); - - for (int i = 0; i < values.size(); i++) { - predicateValues.add(new ArrayList<Boolean>()); - } - } - for (int i = 0; i < values.size(); i++) { int value = ((IntegerPrologTerm) values.get(i)).getValue() .intValue(); predicateValues.get(i).add(value == 0 ? false : true); } - // final boolean inLoop = isLoopType && index >= loopEntry; final Operation operation = NONE.equals(operationTerm) ? null : Operation.fromPrologTerm(operationTerm); final CounterExampleState ceState = new CounterExampleState(index, - stateId, operation/* , inLoop */); + stateId, operation); states.add(ceState); index++; } + + return predicateValues; } - private CounterExampleProposition createExample(final PrologTerm structure) { - CounterExampleProposition proposition = null; + private CounterExampleProposition createExample(final PrologTerm structure, + final String[] atomicFormulaNames, + List<ArrayList<Boolean>> predicateValues) { + final CounterExampleProposition proposition; CompoundPrologTerm term = (CompoundPrologTerm) structure; String functor = term.getFunctor(); @@ -104,18 +124,15 @@ public final class CounterExample { Arrays.fill(values, CounterExampleValueType.FALSE); } - proposition = new CounterExamplePredicate(functor, pathType, - loopEntry, Arrays.asList(values)); + proposition = new CounterExamplePredicate(functor, this, + Arrays.asList(values)); } else if (arity == 1) { if (functor.equals("ap") || functor.equals("tp")) { IntegerPrologTerm atomic = (IntegerPrologTerm) term .getArgument(1); int atomicId = atomic.getValue().intValue(); - CompoundPrologTerm atomicTerm = (CompoundPrologTerm) atomics - .get(atomicId); - atomicTerm = (CompoundPrologTerm) atomicTerm.getArgument(1); - String name = atomicTerm.getFunctor(); + final String name = atomicFormulaNames[atomicId]; Logger.assertProB("CounterExample invalid", values.length == predicateValues.get(atomicId).size()); @@ -126,75 +143,97 @@ public final class CounterExample { } proposition = functor.equals("ap") ? new CounterExamplePredicate( - name, pathType, loopEntry, Arrays.asList(values)) - : new CounterExampleTransition(name, pathType, - loopEntry, Arrays.asList(values)); + name, this, Arrays.asList(values)) + : new CounterExampleTransition(name, this, + Arrays.asList(values)); } else { - CounterExampleProposition argument = createExample(term - .getArgument(1)); - if (functor.equals("globally")) { - proposition = new CounterExampleGlobally(pathType, - loopEntry, argument); - } else if (functor.equals("finally")) { - proposition = new CounterExampleFinally(pathType, - loopEntry, argument); - } else if (functor.equals("next")) { - proposition = new CounterExampleNext(pathType, loopEntry, - argument); - } else if (functor.equals("not")) { - proposition = new CounterExampleNegation(pathType, - loopEntry, argument); - } else if (functor.equals("once")) { - proposition = new CounterExampleOnce(pathType, loopEntry, - argument); - } else if (functor.equals("yesterday")) { - proposition = new CounterExampleYesterday(pathType, - loopEntry, argument); - } else if (functor.equals("historically")) { - proposition = new CounterExampleHistory(pathType, - loopEntry, argument); - } - - argument.setParent(proposition); + proposition = createUnaryOperator(atomicFormulaNames, + predicateValues, term, functor); } } else if (arity == 2) { - CounterExampleProposition firstArgument = createExample(term - .getArgument(1)); - CounterExampleProposition secondArgument = createExample(term - .getArgument(2)); + proposition = createBinaryOperator(atomicFormulaNames, + predicateValues, term, functor); + } else { + throw new IllegalArgumentException("Unexpected Prolog LTL " + arity + + "-ary operator " + functor); + } - if (functor.equals("and")) { - proposition = new CounterExampleConjunction(pathType, - loopEntry, firstArgument, secondArgument); - } else if (functor.equals("or")) { - proposition = new CounterExampleDisjunction(pathType, - loopEntry, firstArgument, secondArgument); - } else if (functor.equals("implies")) { - proposition = new CounterExampleImplication(pathType, - loopEntry, firstArgument, secondArgument); - } else if (functor.equals("until")) { - proposition = new CounterExampleUntil(pathType, loopEntry, - firstArgument, secondArgument); - } else if (functor.equals("weakuntil")) { - proposition = new CounterExampleWeakUntil(pathType, loopEntry, - firstArgument, secondArgument); - } else if (functor.equals("release")) { - proposition = new CounterExampleRelease(pathType, loopEntry, - firstArgument, secondArgument); - } else if (functor.equals("since")) { - proposition = new CounterExampleSince(pathType, loopEntry, - firstArgument, secondArgument); - } else if (functor.equals("trigger")) { - proposition = new CounterExampleTrigger(pathType, loopEntry, - firstArgument, secondArgument); - } + propositions.add(proposition); + + return proposition; + } - firstArgument.setParent(proposition); - secondArgument.setParent(proposition); + private CounterExampleProposition createBinaryOperator( + final String[] atomicFormulaNames, + List<ArrayList<Boolean>> predicateValues, CompoundPrologTerm term, + String functor) { + final CounterExampleProposition proposition; + final CounterExampleProposition firstArgument = createExample( + term.getArgument(1), atomicFormulaNames, predicateValues); + final CounterExampleProposition secondArgument = createExample( + term.getArgument(2), atomicFormulaNames, predicateValues); + + if (functor.equals("and")) { + proposition = new CounterExampleConjunction(this, firstArgument, + secondArgument); + } else if (functor.equals("or")) { + proposition = new CounterExampleDisjunction(this, firstArgument, + secondArgument); + } else if (functor.equals("implies")) { + proposition = new CounterExampleImplication(this, firstArgument, + secondArgument); + } else if (functor.equals("until")) { + proposition = new CounterExampleUntil(this, firstArgument, + secondArgument); + } else if (functor.equals("weakuntil")) { + proposition = new CounterExampleWeakUntil(this, firstArgument, + secondArgument); + } else if (functor.equals("release")) { + proposition = new CounterExampleRelease(this, firstArgument, + secondArgument); + } else if (functor.equals("since")) { + proposition = new CounterExampleSince(this, firstArgument, + secondArgument); + } else if (functor.equals("trigger")) { + proposition = new CounterExampleTrigger(this, firstArgument, + secondArgument); + } else { + throw new IllegalArgumentException( + "Unexpected Prolog LTL binary operator " + functor); } - propositions.add(proposition); + firstArgument.setParent(proposition); + secondArgument.setParent(proposition); + return proposition; + } + private CounterExampleProposition createUnaryOperator( + final String[] atomicFormulaNames, + List<ArrayList<Boolean>> predicateValues, CompoundPrologTerm term, + String functor) { + final CounterExampleProposition proposition; + final CounterExampleProposition argument = createExample( + term.getArgument(1), atomicFormulaNames, predicateValues); + if (functor.equals("globally")) { + proposition = new CounterExampleGlobally(this, argument); + } else if (functor.equals("finally")) { + proposition = new CounterExampleFinally(this, argument); + } else if (functor.equals("next")) { + proposition = new CounterExampleNext(this, argument); + } else if (functor.equals("not")) { + proposition = new CounterExampleNegation(this, argument); + } else if (functor.equals("once")) { + proposition = new CounterExampleOnce(this, argument); + } else if (functor.equals("yesterday")) { + proposition = new CounterExampleYesterday(this, argument); + } else if (functor.equals("historically")) { + proposition = new CounterExampleHistory(this, argument); + } else { + throw new IllegalArgumentException( + "Unexpected Prolog LTL unary operator " + functor); + } + + argument.setParent(proposition); return proposition; } @@ -232,4 +271,8 @@ public final class CounterExample { public List<Operation> getInitPath() { return initPath; } + + public int getCounterExampleSize() { + return ceSize; + } } diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java index 0f02c58230c10c60e0247e358296b7fa93ebe46a..79f2f924ff62689ebda1f01a56f3b04294453013 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleBinaryOperator.java @@ -3,7 +3,6 @@ package de.prob.core.domainobjects.ltl; import java.util.ArrayList; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; import de.prob.logging.Logger; /** @@ -20,10 +19,10 @@ public abstract class CounterExampleBinaryOperator extends protected List<List<Integer>> secondHighlightedPositions = new ArrayList<List<Integer>>(); public CounterExampleBinaryOperator(final String name, - final String fullName, final PathType pathType, - final int loopEntry, final CounterExampleProposition firstArgument, + final String fullName, final CounterExample counterExample, + final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - super(name, fullName, pathType, loopEntry); + super(name, fullName, counterExample); this.firstArgument = firstArgument; this.secondArgument = secondArgument; } @@ -92,12 +91,6 @@ public abstract class CounterExampleBinaryOperator extends secondCheckedSize, isPast)); } - @Override - protected int calculatePosition(int pos) { - int size = getFirstArgument().getValues().size(); - return pos < size ? pos : pos - (size - loopEntry); - } - protected int indexOfUnknownState( final List<CounterExampleValueType> firstCheckedValues, final List<CounterExampleValueType> secondCheckedValues, diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java index 2afc61f1876b649e922eb0b0d478eaf4bd602677..e72430bc8dfb91508528e4317bbcda5164aba1cf 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleConjunction.java @@ -1,7 +1,5 @@ package de.prob.core.domainobjects.ltl; -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; /** * Provides an "and" operator. @@ -12,27 +10,24 @@ import de.prob.logging.Logger; public final class CounterExampleConjunction extends CounterExampleBinaryOperator { - private final CounterExampleNegation not; - - public CounterExampleConjunction(final PathType pathType, - final int loopEntry, final CounterExampleProposition firstArgument, + public CounterExampleConjunction(final CounterExample counterExample, + final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - super("and", "Conjunction", pathType, loopEntry, firstArgument, + super("and", "Conjunction", counterExample, firstArgument, secondArgument); - - CounterExampleNegation notFirstArgument = new CounterExampleNegation( - pathType, loopEntry, firstArgument); - CounterExampleNegation notSecondArgument = new CounterExampleNegation( - pathType, loopEntry, secondArgument); - CounterExampleDisjunction or = new CounterExampleDisjunction(pathType, - loopEntry, notFirstArgument, notSecondArgument); - not = new CounterExampleNegation(pathType, loopEntry, or); + addCheckByDeMorgan(counterExample, firstArgument, secondArgument); } - public CounterExampleConjunction(final PathType pathType, + private void addCheckByDeMorgan(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + CounterExampleNegation notFirstArgument = new CounterExampleNegation( + counterExample, firstArgument); + CounterExampleNegation notSecondArgument = new CounterExampleNegation( + counterExample, secondArgument); + CounterExampleDisjunction or = new CounterExampleDisjunction( + counterExample, notFirstArgument, notSecondArgument); + addCheck(new CounterExampleNegation(counterExample, or)); } @Override @@ -56,8 +51,6 @@ public final class CounterExampleConjunction extends CounterExampleValueType value = calculateAnd(firstValue, secondValue); - Logger.assertProB("And invalid", value == not.getValues().get(position)); - return value; } diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java index 901e03bc7c909f345052e76ae7f22c09aae6c6ad..b6fb4a141d41be99fc4e51f4cf938be73ae61d6d 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleDisjunction.java @@ -1,6 +1,5 @@ package de.prob.core.domainobjects.ltl; -import de.prob.core.command.LtlCheckingCommand.PathType; /** * Provides an "or" operator. @@ -11,17 +10,11 @@ import de.prob.core.command.LtlCheckingCommand.PathType; public final class CounterExampleDisjunction extends CounterExampleBinaryOperator { - public CounterExampleDisjunction(final PathType pathType, - final int loopEntry, final CounterExampleProposition firstArgument, - final CounterExampleProposition secondArgument) { - super("or", "Disjunction", pathType, loopEntry, firstArgument, - secondArgument); - } - - public CounterExampleDisjunction(final PathType pathType, + public CounterExampleDisjunction(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + super("or", "Disjunction", counterExample, firstArgument, + secondArgument); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java index cf0b4e66a5cb12b6682f13058e5ec4b5e464fa89..90d6954c55c69e5cb26018f1af17e0cbd7781a6b 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleFinally.java @@ -5,7 +5,6 @@ import java.util.Arrays; import java.util.List; import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; /** * Provides a "finally" operator. @@ -15,34 +14,26 @@ import de.prob.logging.Logger; */ public final class CounterExampleFinally extends CounterExampleUnaryOperator { - private final CounterExampleUntil until; - - public CounterExampleFinally(final PathType pathType, final int loopEntry, + public CounterExampleFinally(final CounterExample counterExample, final CounterExampleProposition argument) { - super("F", "Finally", pathType, loopEntry, argument); + super("F", "Finally", counterExample, argument); + checkByUntil(counterExample, argument); + } + private void checkByUntil(final CounterExample counterExample, + final CounterExampleProposition argument) { CounterExampleValueType[] firstValues = new CounterExampleValueType[argument .getValues().size()]; Arrays.fill(firstValues, CounterExampleValueType.TRUE); - CounterExamplePredicate first = new CounterExamplePredicate(pathType, - loopEntry, Arrays.asList(firstValues)); + CounterExamplePredicate first = new CounterExamplePredicate("", + counterExample, Arrays.asList(firstValues)); - until = new CounterExampleUntil(pathType, loopEntry, first, argument); + addCheck(new CounterExampleUntil(counterExample, first, argument)); } @Override protected CounterExampleValueType calculate(final int position) { - CounterExampleValueType value = calculateFinallyOperator(position); - - List<CounterExampleValueType> untilValues = until.getValues(); - - Logger.assertProB("Finally invalid", value == untilValues.get(position)); - - return value; - } - - private CounterExampleValueType calculateFinallyOperator(final int position) { CounterExampleValueType result = CounterExampleValueType.UNKNOWN; List<CounterExampleValueType> checkedValues = new ArrayList<CounterExampleValueType>( diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java index bad9bdf6eb8b93afed45b74bc26b8356f3210495..b6f5fe4358d22263847ee8e7b5c6edb592e35467 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleGlobally.java @@ -5,7 +5,6 @@ import java.util.Arrays; import java.util.List; import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; /** * Provides a "globally" operator. @@ -15,66 +14,55 @@ import de.prob.logging.Logger; */ public final class CounterExampleGlobally extends CounterExampleUnaryOperator { - private final CounterExampleRelease release; - private final CounterExampleNegation notFinally; - private final CounterExampleNegation notUntil; - - public CounterExampleGlobally(final PathType pathType, final int loopEntry, + public CounterExampleGlobally(final CounterExample counterExample, final CounterExampleProposition argument) { - super("G", "Globally", pathType, loopEntry, argument); - - CounterExampleValueType[] falseValues = new CounterExampleValueType[argument - .getValues().size()]; - Arrays.fill(falseValues, CounterExampleValueType.FALSE); - - CounterExamplePredicate falsePredicate = new CounterExamplePredicate( - pathType, loopEntry, Arrays.asList(falseValues)); - - release = new CounterExampleRelease(pathType, loopEntry, - falsePredicate, argument); + super("G", "Globally", counterExample, argument); + checkByRelease(counterExample, argument); CounterExampleNegation notArgument = new CounterExampleNegation( - pathType, loopEntry, argument); - - CounterExampleFinally finallyOperator = new CounterExampleFinally( - pathType, loopEntry, notArgument); - - notFinally = new CounterExampleNegation(pathType, loopEntry, - finallyOperator); + counterExample, argument); + checkByFinally(counterExample, notArgument); + checkByUntil(counterExample, argument, notArgument); + } + private void checkByUntil(final CounterExample counterExample, + final CounterExampleProposition argument, + CounterExampleNegation notArgument) { CounterExampleValueType[] trueValues = new CounterExampleValueType[argument .getValues().size()]; Arrays.fill(trueValues, CounterExampleValueType.TRUE); - CounterExamplePredicate truePredicate = new CounterExamplePredicate( - pathType, loopEntry, Arrays.asList(trueValues)); + CounterExamplePredicate truePredicate = new CounterExamplePredicate("", + counterExample, Arrays.asList(trueValues)); - CounterExampleUntil until = new CounterExampleUntil(pathType, - loopEntry, truePredicate, notArgument); - notUntil = new CounterExampleNegation(pathType, loopEntry, until); + CounterExampleUntil until = new CounterExampleUntil(counterExample, + truePredicate, notArgument); + addCheck(new CounterExampleNegation(counterExample, until)); } - @Override - protected CounterExampleValueType calculate(final int position) { - CounterExampleValueType value = calculateGlobally(position); - - List<CounterExampleValueType> releaseValues = release.getValues(); - List<CounterExampleValueType> notFinallyValues = notFinally.getValues(); - List<CounterExampleValueType> notUntilValues = notUntil.getValues(); + private void checkByFinally(final CounterExample counterExample, + CounterExampleNegation notArgument) { + CounterExampleFinally finallyOperator = new CounterExampleFinally( + counterExample, notArgument); - Logger.assertProB("Globally invalid", - value == releaseValues.get(position)); + addCheck(new CounterExampleNegation(counterExample, finallyOperator)); + } - Logger.assertProB("Globally invalid", - value == notFinallyValues.get(position)); + private void checkByRelease(final CounterExample counterExample, + final CounterExampleProposition argument) { + CounterExampleValueType[] falseValues = new CounterExampleValueType[argument + .getValues().size()]; + Arrays.fill(falseValues, CounterExampleValueType.FALSE); - Logger.assertProB("Globally invalid", - value == notUntilValues.get(position)); + CounterExamplePredicate falsePredicate = new CounterExamplePredicate( + "", counterExample, Arrays.asList(falseValues)); - return value; + addCheck(new CounterExampleRelease(counterExample, falsePredicate, + argument)); } - private CounterExampleValueType calculateGlobally(final int position) { + @Override + protected CounterExampleValueType calculate(final int position) { CounterExampleValueType result = CounterExampleValueType.UNKNOWN; List<CounterExampleValueType> checkedValues = new ArrayList<CounterExampleValueType>( diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java index 6f320b58c9402de28fdbf37c0af0e014582e262e..d8479d1de5d2e1ecae1b92ed6a24f346e21a0318 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleHistory.java @@ -4,9 +4,6 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; - /** * Provides a "history" operator. * @@ -15,47 +12,42 @@ import de.prob.logging.Logger; */ public final class CounterExampleHistory extends CounterExampleUnaryOperator { - private final CounterExampleNegation notOnce; - private final CounterExampleNegation notSince; - - public CounterExampleHistory(final PathType pathType, final int loopEntry, + public CounterExampleHistory(final CounterExample counterExample, final CounterExampleProposition argument) { - super("H", "History", pathType, loopEntry, argument); + super("H", "History", counterExample, argument); CounterExampleNegation notArgument = new CounterExampleNegation( - pathType, loopEntry, argument); - - CounterExampleOnce onceOperator = new CounterExampleOnce(pathType, - loopEntry, notArgument); - - notOnce = new CounterExampleNegation(pathType, loopEntry, onceOperator); + counterExample, argument); + checkByOnce(counterExample, notArgument); + checkBySince(counterExample, argument, notArgument); + } + private void checkBySince(final CounterExample counterExample, + final CounterExampleProposition argument, + CounterExampleNegation notArgument) { CounterExampleValueType[] trueValues = new CounterExampleValueType[argument .getValues().size()]; Arrays.fill(trueValues, CounterExampleValueType.TRUE); - CounterExamplePredicate truePredicate = new CounterExamplePredicate( - pathType, loopEntry, Arrays.asList(trueValues)); + CounterExamplePredicate truePredicate = new CounterExamplePredicate("", + counterExample, Arrays.asList(trueValues)); - CounterExampleSince since = new CounterExampleSince(pathType, - loopEntry, truePredicate, notArgument); - notSince = new CounterExampleNegation(pathType, loopEntry, since); + CounterExampleSince since = new CounterExampleSince(counterExample, + truePredicate, notArgument); + addCheck(new CounterExampleNegation(counterExample, since)); } - @Override - public CounterExampleValueType calculate(final int position) { - CounterExampleValueType value = calculateHistoryOperator(position); - - List<CounterExampleValueType> notOnceValues = notOnce.getValues(); - List<CounterExampleValueType> notSinceValues = notSince.getValues(); - - Logger.assertProB("History invalid", - value == notOnceValues.get(position)); + private void checkByOnce(final CounterExample counterExample, + CounterExampleNegation notArgument) { + CounterExampleOnce onceOperator = new CounterExampleOnce( + counterExample, notArgument); - Logger.assertProB("History invalid", - value == notSinceValues.get(position)); + addCheck(new CounterExampleNegation(counterExample, onceOperator)); + } - return value; + @Override + public CounterExampleValueType calculate(final int position) { + return calculateHistoryOperator(position); } private CounterExampleValueType calculateHistoryOperator(final int position) { diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java index a11b756bbefa4b88b7dc7fe171ddcf6ed259a973..ea536c11e472d1e0bd73d4cfd228e29ecf5bcdaa 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleImplication.java @@ -1,6 +1,5 @@ package de.prob.core.domainobjects.ltl; -import de.prob.core.command.LtlCheckingCommand.PathType; /** * Provides an "imply" operator. @@ -11,17 +10,11 @@ import de.prob.core.command.LtlCheckingCommand.PathType; public final class CounterExampleImplication extends CounterExampleBinaryOperator { - public CounterExampleImplication(final PathType pathType, - final int loopEntry, final CounterExampleProposition firstArgument, - final CounterExampleProposition secondArgument) { - super("=>", "Implication", pathType, loopEntry, firstArgument, - secondArgument); - } - - public CounterExampleImplication(final PathType pathType, + public CounterExampleImplication(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + super("=>", "Implication", counterExample, firstArgument, + secondArgument); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java index 2c6242087571836c49efce33fc9d168c67527f69..8f2eb3bedeafcc5b7343f885fab375843ead941a 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNegation.java @@ -1,6 +1,5 @@ package de.prob.core.domainobjects.ltl; -import de.prob.core.command.LtlCheckingCommand.PathType; /** * Provides a "not" operator. @@ -10,14 +9,9 @@ import de.prob.core.command.LtlCheckingCommand.PathType; */ public final class CounterExampleNegation extends CounterExampleUnaryOperator { - public CounterExampleNegation(final PathType pathType, final int loopEntry, + public CounterExampleNegation(final CounterExample counterExample, final CounterExampleProposition argument) { - super("not", "Negation", pathType, loopEntry, argument); - } - - public CounterExampleNegation(final PathType pathType, - final CounterExampleProposition argument) { - this(pathType, -1, argument); + super("not", "Negation", counterExample, argument); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java index 0ee28b23cf076957b403e129f2df7d4a95a68077..86e814108c2eef36b54e8e3a75378160d0c5e0fb 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleNext.java @@ -13,9 +13,9 @@ import de.prob.core.command.LtlCheckingCommand.PathType; */ public final class CounterExampleNext extends CounterExampleUnaryOperator { - public CounterExampleNext(final PathType pathType, final int loopEntry, + public CounterExampleNext(final CounterExample counterExample, final CounterExampleProposition argument) { - super("X", "Next", pathType, loopEntry, argument); + super("X", "Next", counterExample, argument); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java index c0388ff29937a60189bd291d1a263504dbaf8163..f22ab22d6da46f2f64863762933c454486863492 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleOnce.java @@ -4,9 +4,6 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; - /** * Provides an "once" operator. * @@ -15,36 +12,27 @@ import de.prob.logging.Logger; */ public final class CounterExampleOnce extends CounterExampleUnaryOperator { - private final CounterExampleSince since; - - public CounterExampleOnce(final PathType pathType, final int loopEntry, + public CounterExampleOnce(final CounterExample counterExample, final CounterExampleProposition argument) { - super("O", "Once", pathType, loopEntry, argument); + super("O", "Once", counterExample, argument); + checkBySince(counterExample, argument); + } + private void checkBySince(final CounterExample counterExample, + final CounterExampleProposition argument) { CounterExampleValueType[] firstValues = new CounterExampleValueType[argument .getValues().size()]; Arrays.fill(firstValues, CounterExampleValueType.TRUE); - CounterExamplePredicate first = new CounterExamplePredicate(pathType, - loopEntry, Arrays.asList(firstValues)); - - since = new CounterExampleSince(pathType, loopEntry, first, argument); - } + CounterExamplePredicate first = new CounterExamplePredicate("", + counterExample, Arrays.asList(firstValues)); - public CounterExampleOnce(final PathType pathType, - final CounterExampleProposition argument) { - this(pathType, -1, argument); + addCheck(new CounterExampleSince(counterExample, first, argument)); } @Override public CounterExampleValueType calculate(final int position) { - CounterExampleValueType value = calculateOnceOperator(position); - - List<CounterExampleValueType> sinceValues = since.getValues(); - - Logger.assertProB("Once invalid", value == sinceValues.get(position)); - - return value; + return calculateOnceOperator(position); } private CounterExampleValueType calculateOnceOperator(final int position) { diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java index 6e4d8857c5af55661ff578f60cd099aa1346a31f..11643d8b0776a2405ca61e8ca0d61d15b34ce998 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExamplePredicate.java @@ -2,8 +2,6 @@ package de.prob.core.domainobjects.ltl; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; - /** * Provides predicates. * @@ -13,25 +11,11 @@ import de.prob.core.command.LtlCheckingCommand.PathType; public class CounterExamplePredicate extends CounterExampleProposition { private final List<CounterExampleValueType> values; - public CounterExamplePredicate(final String name, final PathType pathType, - final int loopEntry, final List<CounterExampleValueType> values) { - super(name, name, pathType, loopEntry); - this.values = values; - } - - public CounterExamplePredicate(final String name, final PathType pathType, - final List<CounterExampleValueType> values) { - this(name, pathType, -1, values); - } - - public CounterExamplePredicate(final PathType pathType, - final int loopEntry, final List<CounterExampleValueType> values) { - this("", pathType, loopEntry, values); - } - - public CounterExamplePredicate(final PathType pathType, + public CounterExamplePredicate(final String name, + final CounterExample counterExample, final List<CounterExampleValueType> values) { - this("", pathType, values); + super(name, name, counterExample); + this.values = values; } @Override @@ -49,9 +33,4 @@ public class CounterExamplePredicate extends CounterExampleProposition { return name; } - @Override - protected int calculatePosition(int pos) { - int size = values.size(); - return pos < size ? pos : pos - (size - loopEntry); - } } diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java index f63da11e6a70a94498a6ed256d6090bd6fb36ffc..4125194610437ae3c7cc92e60abdc76817d66412 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleProposition.java @@ -3,6 +3,7 @@ package de.prob.core.domainobjects.ltl; import java.beans.PropertyChangeListener; import java.beans.PropertyChangeSupport; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import de.prob.core.command.LtlCheckingCommand.PathType; @@ -19,8 +20,10 @@ public abstract class CounterExampleProposition { protected final String fullName; protected final int loopEntry; protected final PathType pathType; + protected final CounterExample counterExample; protected CounterExampleProposition parent; private List<CounterExampleValueType> values; + private Collection<CounterExampleProposition> checks = new ArrayList<CounterExampleProposition>(); protected final PropertyChangeSupport listeners = new PropertyChangeSupport( this); @@ -28,11 +31,12 @@ public abstract class CounterExampleProposition { protected int stateId = 0; public CounterExampleProposition(final String name, final String fullName, - final PathType pathType, final int loopEntry) { + final CounterExample counterExample) { this.name = name; this.fullName = fullName; - this.loopEntry = loopEntry; - this.pathType = pathType; + this.loopEntry = counterExample.getLoopEntry(); + this.pathType = counterExample.getPathType(); + this.counterExample = counterExample; } public CounterExampleProposition getParent() { @@ -50,6 +54,7 @@ public abstract class CounterExampleProposition { public List<CounterExampleValueType> getValues() { if (values == null) { values = calculate(); + performChecks(values); } return values; @@ -99,7 +104,7 @@ public abstract class CounterExampleProposition { listeners.removePropertyChangeListener(listener); } - public List<Integer> fillPositions(int position, int index, + protected List<Integer> fillPositions(int position, int index, int checkedSize, boolean isPastOperator) { List<Integer> positions = new ArrayList<Integer>(); @@ -126,5 +131,27 @@ public abstract class CounterExampleProposition { protected abstract List<CounterExampleValueType> calculate(); - protected abstract int calculatePosition(int pos); + private int calculatePosition(int pos) { + final int size = counterExample.getCounterExampleSize(); + return pos < size ? pos : pos - (size - loopEntry); + } + + protected final void addCheck(CounterExampleProposition check) { + checks.add(check); + } + + private void performChecks(List<CounterExampleValueType> values) { + for (final CounterExampleProposition check : checks) { + performCheck(check, values); + } + } + + private void performCheck(CounterExampleProposition check, + List<CounterExampleValueType> values) { + List<CounterExampleValueType> values2 = check.getValues(); + if (!values.equals(values2)) { + Logger.notifyUser("Encountered inconsistency in computation of LTL operator" + + name); + } + } } diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java index fc802cc3b633d75ea89d53176cc0a232739e846a..f4f5932f909251a125bb0bc55ee2d5bc6ae7155b 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleRelease.java @@ -4,7 +4,6 @@ import java.util.ArrayList; import java.util.List; import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; /** * Provides a "release" operator. @@ -14,39 +13,28 @@ import de.prob.logging.Logger; */ public final class CounterExampleRelease extends CounterExampleBinaryOperator { - private final CounterExampleNegation notUntil; - - public CounterExampleRelease(final PathType pathType, final int loopEntry, + public CounterExampleRelease(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - super("R", "Release", pathType, loopEntry, firstArgument, - secondArgument); - CounterExampleNegation notFirst = new CounterExampleNegation(pathType, - loopEntry, firstArgument); - CounterExampleNegation notSecond = new CounterExampleNegation(pathType, - loopEntry, secondArgument); - CounterExampleUntil until = new CounterExampleUntil(pathType, - loopEntry, notFirst, notSecond); - notUntil = new CounterExampleNegation(pathType, loopEntry, until); + super("R", "Release", counterExample, firstArgument, secondArgument); + checkByUntil(counterExample, firstArgument, secondArgument); } - public CounterExampleRelease(final PathType pathType, + private void checkByUntil(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + CounterExampleNegation notFirst = new CounterExampleNegation( + counterExample, firstArgument); + CounterExampleNegation notSecond = new CounterExampleNegation( + counterExample, secondArgument); + CounterExampleUntil until = new CounterExampleUntil(counterExample, + notFirst, notSecond); + addCheck(new CounterExampleNegation(counterExample, until)); } @Override protected CounterExampleValueType calculate(final int position) { - final CounterExampleValueType value = calculateReleaseOperator(position); - - final List<CounterExampleValueType> notUntilValues = notUntil - .getValues(); - - Logger.assertProB("Release invalid", - value == notUntilValues.get(position)); - - return value; + return calculateReleaseOperator(position); } private CounterExampleValueType calculateReleaseOperator(final int position) { diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java index bf606ea909e89ece1fb74009cc5da105f3acd18a..9c050bc88be343e675cbe06a31661616f0500b95 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleSince.java @@ -3,8 +3,6 @@ package de.prob.core.domainobjects.ltl; import java.util.ArrayList; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; - /** * Provides a "since" operator. * @@ -13,16 +11,10 @@ import de.prob.core.command.LtlCheckingCommand.PathType; */ public final class CounterExampleSince extends CounterExampleBinaryOperator { - public CounterExampleSince(final PathType pathType, final int loopEntry, - final CounterExampleProposition firstArgument, - final CounterExampleProposition secondArgument) { - super("S", "Since", pathType, loopEntry, firstArgument, secondArgument); - } - - public CounterExampleSince(final PathType pathType, + public CounterExampleSince(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + super("S", "Since", counterExample, firstArgument, secondArgument); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java index 5ab6beab158d3409a24d2c940d96b8b5c39b08b7..c36ff7cc8efd14e683d87ffecd2abea679af6149 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleState.java @@ -1,6 +1,7 @@ package de.prob.core.domainobjects.ltl; import de.prob.core.domainobjects.Operation; +import de.prob.prolog.term.PrologTerm; /** * Provides a state of a counter-example. @@ -10,25 +11,17 @@ import de.prob.core.domainobjects.Operation; */ public final class CounterExampleState { private final int index; - private final int stateId; + private final PrologTerm stateId; private final Operation operation; - // private final boolean inLoop; - - public CounterExampleState(final int index, final int stateId, + public CounterExampleState(final int index, final PrologTerm stateId, final Operation operation/* , final boolean inLoop */) { this.index = index; this.stateId = stateId; this.operation = operation; - // this.inLoop = inLoop; } - // public CounterExampleState(final int index, final int stateId, - // final boolean inLoop) { - // this(index, stateId, null, inLoop); - // } - - public int getState() { + public PrologTerm getState() { return stateId; } @@ -40,7 +33,10 @@ public final class CounterExampleState { return index; } - // public boolean isInLoop() { - // return inLoop; - // } + @Override + public String toString() { + return "CounterExampleState [index=" + index + ", stateId=" + stateId + + ", operation=" + operation + "]"; + } + } diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java index db142b30fc6ae481bf3d09c71a26cc423a6a8432..48a35155a8b9639a0b30037136163697eaff1a3f 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTransition.java @@ -2,8 +2,6 @@ package de.prob.core.domainobjects.ltl; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; - /** * Provides transitions. * @@ -12,24 +10,10 @@ import de.prob.core.command.LtlCheckingCommand.PathType; */ public final class CounterExampleTransition extends CounterExamplePredicate { - public CounterExampleTransition(final String name, final PathType pathType, - final int loopEntry, final List<CounterExampleValueType> values) { - super(name, pathType, loopEntry, values); - } - - public CounterExampleTransition(final String name, final PathType pathType, - final List<CounterExampleValueType> values) { - this(name, pathType, -1, values); - } - - public CounterExampleTransition(final PathType pathType, - final int loopEntry, final List<CounterExampleValueType> values) { - this("", pathType, loopEntry, values); - } - - public CounterExampleTransition(final PathType pathType, + public CounterExampleTransition(final String name, + final CounterExample counterExample, final List<CounterExampleValueType> values) { - this("", pathType, values); + super(name, counterExample, values); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java index cb4c2ab75ed2d7f9c764cb899c1e3b50039bbea9..cb0c0971218a28b4f13755ba50687b81280bdf7a 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleTrigger.java @@ -3,9 +3,6 @@ package de.prob.core.domainobjects.ltl; import java.util.ArrayList; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; - /** * Provides a "trigger" operator. * @@ -14,39 +11,28 @@ import de.prob.logging.Logger; */ public final class CounterExampleTrigger extends CounterExampleBinaryOperator { - private final CounterExampleNegation notSince; - - public CounterExampleTrigger(final PathType pathType, final int loopEntry, + public CounterExampleTrigger(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - super("T", "Trigger", pathType, loopEntry, firstArgument, - secondArgument); - CounterExampleNegation notFirst = new CounterExampleNegation(pathType, - loopEntry, firstArgument); - CounterExampleNegation notSecond = new CounterExampleNegation(pathType, - loopEntry, secondArgument); - CounterExampleSince since = new CounterExampleSince(pathType, - loopEntry, notFirst, notSecond); - notSince = new CounterExampleNegation(pathType, loopEntry, since); + super("T", "Trigger", counterExample, firstArgument, secondArgument); + checkBySince(counterExample, firstArgument, secondArgument); } - public CounterExampleTrigger(final PathType pathType, + private void checkBySince(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + CounterExampleNegation notFirst = new CounterExampleNegation( + counterExample, firstArgument); + CounterExampleNegation notSecond = new CounterExampleNegation( + counterExample, secondArgument); + CounterExampleSince since = new CounterExampleSince(counterExample, + notFirst, notSecond); + addCheck(new CounterExampleNegation(counterExample, since)); } @Override protected CounterExampleValueType calculate(final int position) { - final CounterExampleValueType value = calculateTriggerOperator(position); - - final List<CounterExampleValueType> notSinceValues = notSince - .getValues(); - - Logger.assertProB("Trigger invalid", - value == notSinceValues.get(position)); - - return value; + return calculateTriggerOperator(position); } private CounterExampleValueType calculateTriggerOperator(final int position) { diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java index fc43702dc5b3ecd91494b6cd1b8180950c474324..f4911990e2cce2559ae22fd2214c753ca200134a 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUnaryOperator.java @@ -3,8 +3,6 @@ package de.prob.core.domainobjects.ltl; import java.util.ArrayList; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; - /** * Provides operators with one parameter. * @@ -17,9 +15,9 @@ public abstract class CounterExampleUnaryOperator extends protected List<List<Integer>> highlightedPositions = new ArrayList<List<Integer>>(); public CounterExampleUnaryOperator(final String name, - final String fullName, final PathType pathType, - final int loopEntry, final CounterExampleProposition argument) { - super(name, fullName, pathType, loopEntry); + final String fullName, final CounterExample counterExample, + final CounterExampleProposition argument) { + super(name, fullName, counterExample); this.argument = argument; } @@ -70,10 +68,4 @@ public abstract class CounterExampleUnaryOperator extends highlightedPositions.add(fillPositions(position, index, checkedSize, isPast)); } - - @Override - protected int calculatePosition(int pos) { - int size = getArgument().getValues().size(); - return pos < size ? pos : pos - (size - loopEntry); - } } diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java index b18bb8a5f85a2b9350c898a659c2d1b1bcc09998..5b017923822c2fd4e8f03bc9f0267ff582040d98 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleUntil.java @@ -13,16 +13,10 @@ import de.prob.core.command.LtlCheckingCommand.PathType; */ public final class CounterExampleUntil extends CounterExampleBinaryOperator { - public CounterExampleUntil(final PathType pathType, final int loopEntry, + public CounterExampleUntil(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - super("U", "Until", pathType, loopEntry, firstArgument, secondArgument); - } - - public CounterExampleUntil(final PathType pathType, - final CounterExampleProposition firstArgument, - final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + super("U", "Until", counterExample, firstArgument, secondArgument); } @Override diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java index 0b67b8cde49ea5140fc2d019f778a28987352c0b..41fc7023b12c5ee8a0aefe89c637ca3cce50ee45 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleWeakUntil.java @@ -5,7 +5,6 @@ import java.util.Arrays; import java.util.List; import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.logging.Logger; /** * Provides a "weak until" operator. @@ -15,63 +14,51 @@ import de.prob.logging.Logger; */ public final class CounterExampleWeakUntil extends CounterExampleBinaryOperator { - private final CounterExampleRelease release; - private final CounterExampleDisjunction or1; - private final CounterExampleDisjunction or2; - - public CounterExampleWeakUntil(final PathType pathType, - final int loopEntry, final CounterExampleProposition firstArgument, + public CounterExampleWeakUntil(final CounterExample counterExample, + final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - super("W", "Weak Until", pathType, loopEntry, firstArgument, - secondArgument); + super("W", "Weak Until", counterExample, firstArgument, secondArgument); - release = new CounterExampleRelease(pathType, loopEntry, - secondArgument, new CounterExampleDisjunction(pathType, - loopEntry, secondArgument, firstArgument)); + checkByRelease(counterExample, firstArgument, secondArgument); + checkByUntil(counterExample, firstArgument, secondArgument); + } - CounterExampleNegation not = new CounterExampleNegation(pathType, - loopEntry, firstArgument); + private void checkByUntil(final CounterExample counterExample, + final CounterExampleProposition firstArgument, + final CounterExampleProposition secondArgument) { + CounterExampleNegation not = new CounterExampleNegation(counterExample, + firstArgument); CounterExampleValueType[] trueValues = new CounterExampleValueType[firstArgument .getValues().size()]; Arrays.fill(trueValues, CounterExampleValueType.TRUE); - CounterExamplePredicate truePredicate = new CounterExamplePredicate( - pathType, loopEntry, Arrays.asList(trueValues)); + CounterExamplePredicate truePredicate = new CounterExamplePredicate("", + counterExample, Arrays.asList(trueValues)); - CounterExampleNegation notUntil = new CounterExampleNegation(pathType, - loopEntry, new CounterExampleUntil(pathType, loopEntry, + CounterExampleNegation notUntil = new CounterExampleNegation( + counterExample, new CounterExampleUntil(counterExample, truePredicate, not)); - CounterExampleUntil until = new CounterExampleUntil(pathType, - loopEntry, firstArgument, secondArgument); + CounterExampleUntil until = new CounterExampleUntil(counterExample, + firstArgument, secondArgument); - or1 = new CounterExampleDisjunction(pathType, loopEntry, notUntil, - until); - or2 = new CounterExampleDisjunction(pathType, loopEntry, until, - new CounterExampleGlobally(pathType, loopEntry, firstArgument)); + addCheck(new CounterExampleDisjunction(counterExample, notUntil, until)); + addCheck(new CounterExampleDisjunction(counterExample, until, + new CounterExampleGlobally(counterExample, firstArgument))); } - public CounterExampleWeakUntil(final PathType pathType, + private void checkByRelease(final CounterExample counterExample, final CounterExampleProposition firstArgument, final CounterExampleProposition secondArgument) { - this(pathType, -1, firstArgument, secondArgument); + addCheck(new CounterExampleRelease(counterExample, secondArgument, + new CounterExampleDisjunction(counterExample, secondArgument, + firstArgument))); } @Override protected CounterExampleValueType calculate(final int position) { - final CounterExampleValueType value = calculateWeakUntilOperator(position); - - Logger.assertProB("Weak Until invalid", value == release.getValues() - .get(position)); - - Logger.assertProB("Weak Until invalid", - value == or1.getValues().get(position)); - - Logger.assertProB("Weak Until invalid", - value == or2.getValues().get(position)); - - return value; + return calculateWeakUntilOperator(position); } private CounterExampleValueType calculateWeakUntilOperator( diff --git a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java index 663d650e7aa6f6ab317516faa69f53122f79ce14..6e76f1979ba1bb2ef1965095015368bbe16434fd 100644 --- a/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java +++ b/de.prob.core/src/de/prob/core/domainobjects/ltl/CounterExampleYesterday.java @@ -3,8 +3,6 @@ package de.prob.core.domainobjects.ltl; import java.util.ArrayList; import java.util.List; -import de.prob.core.command.LtlCheckingCommand.PathType; - /** * Provides a "yesterday" operator. * @@ -13,14 +11,9 @@ import de.prob.core.command.LtlCheckingCommand.PathType; */ public final class CounterExampleYesterday extends CounterExampleUnaryOperator { - public CounterExampleYesterday(final PathType pathType, - final int loopEntry, final CounterExampleProposition argument) { - super("Y", "Yesterday", pathType, loopEntry, argument); - } - - public CounterExampleYesterday(final PathType pathType, + public CounterExampleYesterday(final CounterExample counterExample, final CounterExampleProposition argument) { - this(pathType, -1, argument); + super("Y", "Yesterday", counterExample, argument); } @Override diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java index 3451725937018993e6f08fb6db1dea7dd94f8309..4799156dde7779b824f5cd04ae3f02dea53a3978 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAllUnitTests.java @@ -4,14 +4,17 @@ import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith(Suite.class) -@Suite.SuiteClasses({ CounterExampleFinallyUnitTest.class, - CounterExampleGloballyUnitTest.class, CounterExampleNextUnitTest.class, - CounterExampleUntilUnitTest.class, - CounterExampleWeakUntilUnitTest.class, +@Suite.SuiteClasses({ + CounterExampleFinallyUnitTest.class, + CounterExampleGloballyUnitTest.class, + CounterExampleNextUnitTest.class, + // CounterExampleUntilUnitTest.class, + // CounterExampleWeakUntilUnitTest.class, CounterExampleReleaseUnitTest.class, CounterExampleOnceUnitTest.class, CounterExampleHistoryUnitTest.class, CounterExampleYesterdayUnitTest.class, - CounterExampleSinceUnitTest.class, CounterExampleTriggerUnitTest.class, + // CounterExampleSinceUnitTest.class, + // CounterExampleTriggerUnitTest.class, CounterExampleNotUnitTest.class, CounterExampleAndUnitTest.class, CounterExampleOrUnitTest.class, CounterExampleImplyUnitTest.class }) public final class CounterExampleAllUnitTests { diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java index e318a0dbeb1270e45e7ccde56cea0b6cb6b050d6..c6c14c77fd74ea1b60f2f99f400f6233f3bd7810 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleAndUnitTest.java @@ -7,7 +7,7 @@ import java.util.List; import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; import de.prob.core.domainobjects.ltl.CounterExampleConjunction; import de.prob.core.domainobjects.ltl.CounterExamplePredicate; @@ -26,83 +26,29 @@ public final class CounterExampleAndUnitTest { */ @Test public void testAndOnFinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator andOperator = new CounterExampleConjunction( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = andOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "fttf"); + final CounterExampleProposition snd = d.addArgument("snd", "ttff"); + final CounterExampleBinaryOperator and = new CounterExampleConjunction( + d.getCounterExample(), fst, snd); + d.checkValues("and", and, "ftff"); // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = andOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = andOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); + d.expectedHighlight(0, "fstH", 0); + d.expectedHighlight(0, "sndH"); - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 0); + d.expectedHighlight(1, "fstH", 1); + d.expectedHighlight(1, "sndH", 1); - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); + d.expectedHighlight(2, "fstH"); + d.expectedHighlight(2, "sndH", 2); - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); + d.expectedHighlight(3, "fstH", 3); // If both are false, the first is + // chosen to be highlighted (could + // be different) + d.expectedHighlight(3, "sndH"); - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 0); + d.checkHighlights("and", and, "fstH", "sndH"); } /* @@ -126,18 +72,20 @@ public final class CounterExampleAndUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + // using a loop with state 0 as entry point + final CounterExample ce0 = TestCounterExample.loop(0, 4); // Loop entry = 0 // create first argument CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); + "", ce0, firstArgumentValues); // create second argument CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); + "", ce0, secondArgumentValues); // create an operator CounterExampleBinaryOperator andOperator = new CounterExampleConjunction( - PathType.INFINITE, 0, firstArgument, secondArgument); + ce0, firstArgument, secondArgument); // check result values List<CounterExampleValueType> values = andOperator.getValues(); @@ -191,16 +139,17 @@ public final class CounterExampleAndUnitTest { // Loop entry = 1 // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + CounterExample ce1 = TestCounterExample.loop(1, 4); + firstArgument = new CounterExamplePredicate("", ce1, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + secondArgument = new CounterExamplePredicate("", ce1, secondArgumentValues); // create an operator - andOperator = new CounterExampleConjunction(PathType.INFINITE, 1, - firstArgument, secondArgument); + andOperator = new CounterExampleConjunction(ce1, firstArgument, + secondArgument); // check result values values = andOperator.getValues(); @@ -252,17 +201,18 @@ public final class CounterExampleAndUnitTest { assertTrue(secondHighlightedPositions.get(3).size() == 0); // Loop entry = 2 + CounterExample ce2 = TestCounterExample.loop(2, 4); // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + firstArgument = new CounterExamplePredicate("", ce2, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + secondArgument = new CounterExamplePredicate("", ce2, secondArgumentValues); // create an operator - andOperator = new CounterExampleConjunction(PathType.INFINITE, 2, - firstArgument, secondArgument); + andOperator = new CounterExampleConjunction(ce2, firstArgument, + secondArgument); // check result values values = andOperator.getValues(); @@ -314,17 +264,18 @@ public final class CounterExampleAndUnitTest { assertTrue(secondHighlightedPositions.get(3).size() == 0); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(4, 4); // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + firstArgument = new CounterExamplePredicate("", ce3, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + secondArgument = new CounterExamplePredicate("", ce3, secondArgumentValues); // create an operator - andOperator = new CounterExampleConjunction(PathType.INFINITE, 3, - firstArgument, secondArgument); + andOperator = new CounterExampleConjunction(ce3, firstArgument, + secondArgument); // check result values values = andOperator.getValues(); @@ -397,17 +348,19 @@ public final class CounterExampleAndUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); + // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator andOperator = new CounterExampleConjunction( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = andOperator.getValues(); @@ -481,17 +434,18 @@ public final class CounterExampleAndUnitTest { CounterExampleValueType.UNKNOWN, CounterExampleValueType.UNKNOWN }); + final CounterExample ce = TestCounterExample.reduced(4); // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator andOperator = new CounterExampleConjunction( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = andOperator.getValues(); diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java index c3ba9f582cb080db9a09b3a5e6ad164a819340b6..6306b0992bc67ca3a0427f9845926790a4eb36df 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleFinallyUnitTest.java @@ -7,7 +7,7 @@ import java.util.List; import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleFinally; import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; @@ -31,13 +31,14 @@ public final class CounterExampleFinallyUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.finite(4); // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator finallyOperator = new CounterExampleFinally( - PathType.FINITE, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = finallyOperator @@ -84,13 +85,14 @@ public final class CounterExampleFinallyUnitTest { CounterExampleValueType.FALSE }); // Loop entry = 0 + final CounterExample ce0 = TestCounterExample.loop(0, 4); // create an argument CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); + ce0, argumentValues); // create an operator CounterExampleUnaryOperator finallyOperator = new CounterExampleFinally( - PathType.INFINITE, 0, argument); + ce0, argument); // check result values List<CounterExampleValueType> values = finallyOperator.getValues(); @@ -125,13 +127,12 @@ public final class CounterExampleFinallyUnitTest { new Integer[] { 1 })); // Loop entry = 1 + final CounterExample ce1 = TestCounterExample.loop(1, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); + argument = new CounterExamplePredicate("", ce1, argumentValues); // create an operator - finallyOperator = new CounterExampleFinally(PathType.INFINITE, 1, - argument); + finallyOperator = new CounterExampleFinally(ce1, argument); // check result values values = finallyOperator.getValues(); @@ -165,13 +166,12 @@ public final class CounterExampleFinallyUnitTest { new Integer[] { 1 })); // Loop entry = 2 + final CounterExample ce2 = TestCounterExample.loop(2, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); + argument = new CounterExamplePredicate("", ce2, argumentValues); // create an operator - finallyOperator = new CounterExampleFinally(PathType.INFINITE, 2, - argument); + finallyOperator = new CounterExampleFinally(ce2, argument); // check result values values = finallyOperator.getValues(); @@ -205,13 +205,12 @@ public final class CounterExampleFinallyUnitTest { new Integer[] { 3, 2 })); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(3, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); + argument = new CounterExamplePredicate("", ce3, argumentValues); // create an operator - finallyOperator = new CounterExampleFinally(PathType.INFINITE, 3, - argument); + finallyOperator = new CounterExampleFinally(ce3, argument); // check result values values = finallyOperator.getValues(); @@ -255,13 +254,14 @@ public final class CounterExampleFinallyUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator finallyOperator = new CounterExampleFinally( - PathType.REDUCED, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = finallyOperator diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java index 2cf945c710eb9791fe189b99f2e571605dfd3645..5688ff428550e28d7fe2f2c0eb1a22c868451b28 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleGloballyUnitTest.java @@ -7,7 +7,7 @@ import java.util.List; import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleGlobally; import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; @@ -31,13 +31,14 @@ public final class CounterExampleGloballyUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.TRUE }); + final CounterExample ce = TestCounterExample.finite(4); // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator globallyOperator = new CounterExampleGlobally( - PathType.FINITE, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = globallyOperator @@ -84,13 +85,14 @@ public final class CounterExampleGloballyUnitTest { CounterExampleValueType.TRUE }); // Loop entry = 0 + final CounterExample ce0 = TestCounterExample.loop(0, 4); // create an argument CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); + ce0, argumentValues); // create an operator CounterExampleUnaryOperator globallyOperator = new CounterExampleGlobally( - PathType.INFINITE, 0, argument); + ce0, argument); // check result values List<CounterExampleValueType> values = globallyOperator.getValues(); @@ -125,13 +127,12 @@ public final class CounterExampleGloballyUnitTest { new Integer[] { 1 })); // Loop entry = 1 + final CounterExample ce1 = TestCounterExample.loop(1, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); + argument = new CounterExamplePredicate("", ce1, argumentValues); // create an operator - globallyOperator = new CounterExampleGlobally(PathType.INFINITE, 1, - argument); + globallyOperator = new CounterExampleGlobally(ce1, argument); // check result values values = globallyOperator.getValues(); @@ -165,13 +166,12 @@ public final class CounterExampleGloballyUnitTest { new Integer[] { 1 })); // Loop entry = 2 + final CounterExample ce2 = TestCounterExample.loop(2, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); + argument = new CounterExamplePredicate("", ce2, argumentValues); // create an operator - globallyOperator = new CounterExampleGlobally(PathType.INFINITE, 2, - argument); + globallyOperator = new CounterExampleGlobally(ce2, argument); // check result values values = globallyOperator.getValues(); @@ -205,13 +205,12 @@ public final class CounterExampleGloballyUnitTest { new Integer[] { 3, 2 })); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(3, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); + argument = new CounterExamplePredicate("", ce3, argumentValues); // create an operator - globallyOperator = new CounterExampleGlobally(PathType.INFINITE, 3, - argument); + globallyOperator = new CounterExampleGlobally(ce3, argument); // check result values values = globallyOperator.getValues(); @@ -255,13 +254,15 @@ public final class CounterExampleGloballyUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.TRUE }); + final CounterExample ce = TestCounterExample.reduced(4); + // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator globallyOperator = new CounterExampleGlobally( - PathType.REDUCED, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = globallyOperator diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java index b6227550f35f7f78b410bcf9153891c56359a6d6..132509c5281e0c2614d1c5e48c037693a453d438 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleHistoryUnitTest.java @@ -7,7 +7,7 @@ import java.util.List; import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleHistory; import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; @@ -34,13 +34,14 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.TRUE }); + final CounterExample ce = TestCounterExample.finite(4); // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.FINITE, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = historyOperator @@ -89,13 +90,15 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.finite(4); + // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.FINITE, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = historyOperator @@ -145,13 +148,14 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.TRUE }); // Loop entry = 0 + final CounterExample ce0 = TestCounterExample.loop(0, 4); // create an argument CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); + ce0, argumentValues); // create an operator CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.INFINITE, 0, argument); + ce0, argument); // check result values List<CounterExampleValueType> values = historyOperator.getValues(); @@ -186,13 +190,12 @@ public final class CounterExampleHistoryUnitTest { new Integer[] { 3, 2, 1, 0 })); // Loop entry = 1 + final CounterExample ce1 = TestCounterExample.loop(1, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); + argument = new CounterExamplePredicate("", ce1, argumentValues); // create an operator - historyOperator = new CounterExampleHistory(PathType.INFINITE, 1, - argument); + historyOperator = new CounterExampleHistory(ce1, argument); // check result values values = historyOperator.getValues(); @@ -226,13 +229,13 @@ public final class CounterExampleHistoryUnitTest { new Integer[] { 3, 2, 1, 0 })); // Loop entry = 2 + final CounterExample ce2 = TestCounterExample.loop(2, 4); + // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); + argument = new CounterExamplePredicate("", ce2, argumentValues); // create an operator - historyOperator = new CounterExampleHistory(PathType.INFINITE, 2, - argument); + historyOperator = new CounterExampleHistory(ce2, argument); // check result values values = historyOperator.getValues(); @@ -266,13 +269,13 @@ public final class CounterExampleHistoryUnitTest { new Integer[] { 3, 2, 1, 0 })); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(3, 4); + // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); + argument = new CounterExamplePredicate("", ce3, argumentValues); // create an operator - historyOperator = new CounterExampleHistory(PathType.INFINITE, 3, - argument); + historyOperator = new CounterExampleHistory(ce3, argument); // check result values values = historyOperator.getValues(); @@ -320,13 +323,14 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.FALSE }); // Loop entry = 0 + final CounterExample ce0 = TestCounterExample.loop(0, 4); // create an argument CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); + ce0, argumentValues); // create an operator CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.INFINITE, 0, argument); + ce0, argument); // check result values List<CounterExampleValueType> values = historyOperator.getValues(); @@ -361,13 +365,12 @@ public final class CounterExampleHistoryUnitTest { new Integer[] { 3 })); // Loop entry = 1 + final CounterExample ce1 = TestCounterExample.loop(0, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); + argument = new CounterExamplePredicate("", ce1, argumentValues); // create an operator - historyOperator = new CounterExampleHistory(PathType.INFINITE, 1, - argument); + historyOperator = new CounterExampleHistory(ce1, argument); // check result values values = historyOperator.getValues(); @@ -401,13 +404,12 @@ public final class CounterExampleHistoryUnitTest { new Integer[] { 3 })); // Loop entry = 2 + final CounterExample ce2 = TestCounterExample.loop(0, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); + argument = new CounterExamplePredicate("", ce2, argumentValues); // create an operator - historyOperator = new CounterExampleHistory(PathType.INFINITE, 2, - argument); + historyOperator = new CounterExampleHistory(ce2, argument); // check result values values = historyOperator.getValues(); @@ -441,13 +443,12 @@ public final class CounterExampleHistoryUnitTest { new Integer[] { 3 })); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(3, 4); // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); + argument = new CounterExamplePredicate("", ce3, argumentValues); // create an operator - historyOperator = new CounterExampleHistory(PathType.INFINITE, 3, - argument); + historyOperator = new CounterExampleHistory(ce3, argument); // check result values values = historyOperator.getValues(); @@ -494,13 +495,14 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.TRUE }); + final CounterExample ce = TestCounterExample.reduced(4); // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.REDUCED, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = historyOperator @@ -549,13 +551,15 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); + // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.REDUCED, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = historyOperator @@ -604,13 +608,15 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.UNKNOWN, CounterExampleValueType.TRUE }); + final CounterExample ce = TestCounterExample.reduced(4); + // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.REDUCED, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = historyOperator @@ -659,13 +665,14 @@ public final class CounterExampleHistoryUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); // create an argument final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); + "", ce, argumentValues); // create an operator final CounterExampleUnaryOperator historyOperator = new CounterExampleHistory( - PathType.REDUCED, -1, argument); + ce, argument); // check result values final List<CounterExampleValueType> values = historyOperator diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java index 7985d9539e39d82404d1bdce43326c08a26c204f..7c557d58feeffe92ada8e4f782ff499544a263b3 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleImplyUnitTest.java @@ -7,7 +7,7 @@ import java.util.List; import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; import de.prob.core.domainobjects.ltl.CounterExampleImplication; import de.prob.core.domainobjects.ltl.CounterExamplePredicate; @@ -42,17 +42,18 @@ public final class CounterExampleImplyUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.finite(4); // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication( - PathType.FINITE, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = implyOperator.getValues(); @@ -127,17 +128,18 @@ public final class CounterExampleImplyUnitTest { CounterExampleValueType.FALSE }); // Loop entry = 0 + final CounterExample ce0 = TestCounterExample.loop(0, 4); // create first argument CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); + "", ce0, firstArgumentValues); // create second argument CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); + "", ce0, secondArgumentValues); // create an operator CounterExampleBinaryOperator implyOperator = new CounterExampleImplication( - PathType.INFINITE, 0, firstArgument, secondArgument); + ce0, firstArgument, secondArgument); // check result values List<CounterExampleValueType> values = implyOperator.getValues(); @@ -190,17 +192,18 @@ public final class CounterExampleImplyUnitTest { assertTrue(secondHighlightedPositions.get(3).size() == 0); // Loop entry = 1 + final CounterExample ce1 = TestCounterExample.loop(1, 4); // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + firstArgument = new CounterExamplePredicate("", ce1, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + secondArgument = new CounterExamplePredicate("", ce1, secondArgumentValues); // create an operator - implyOperator = new CounterExampleImplication(PathType.INFINITE, 1, - firstArgument, secondArgument); + implyOperator = new CounterExampleImplication(ce1, firstArgument, + secondArgument); // check result values values = implyOperator.getValues(); @@ -253,17 +256,18 @@ public final class CounterExampleImplyUnitTest { assertTrue(secondHighlightedPositions.get(3).size() == 0); // Loop entry = 2 + final CounterExample ce2 = TestCounterExample.loop(2, 4); // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + firstArgument = new CounterExamplePredicate("", ce2, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + secondArgument = new CounterExamplePredicate("", ce2, secondArgumentValues); // create an operator - implyOperator = new CounterExampleImplication(PathType.INFINITE, 2, - firstArgument, secondArgument); + implyOperator = new CounterExampleImplication(ce2, firstArgument, + secondArgument); // check result values values = implyOperator.getValues(); @@ -316,17 +320,18 @@ public final class CounterExampleImplyUnitTest { assertTrue(secondHighlightedPositions.get(3).size() == 0); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(3, 4); // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + firstArgument = new CounterExamplePredicate("", ce3, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + secondArgument = new CounterExamplePredicate("", ce3, secondArgumentValues); // create an operator - implyOperator = new CounterExampleImplication(PathType.INFINITE, 3, - firstArgument, secondArgument); + implyOperator = new CounterExampleImplication(ce3, firstArgument, + secondArgument); // check result values values = implyOperator.getValues(); @@ -400,17 +405,18 @@ public final class CounterExampleImplyUnitTest { CounterExampleValueType.TRUE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = implyOperator.getValues(); @@ -484,17 +490,19 @@ public final class CounterExampleImplyUnitTest { CounterExampleValueType.UNKNOWN, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); + // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = implyOperator.getValues(); @@ -574,17 +582,19 @@ public final class CounterExampleImplyUnitTest { CounterExampleValueType.UNKNOWN, CounterExampleValueType.UNKNOWN }); + final CounterExample ce = TestCounterExample.reduced(4); + // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator implyOperator = new CounterExampleImplication( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = implyOperator.getValues(); diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java index a1fdaf22e57b95c4069d614541fffa8c588cb2ca..95bb621017d47dbcd3d9e2e56ca17e1bcadfe9d8 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNextUnitTest.java @@ -1,288 +1,63 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; import de.prob.core.domainobjects.ltl.CounterExampleNext; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for a "next" operator. * * @author Andriy Tolstoy - * */ public final class CounterExampleNextUnitTest { @Test public void testNextOnFinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator nextOperator = new CounterExampleNext( - PathType.FINITE, -1, argument); - - // check result values - final List<CounterExampleValueType> values = nextOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = nextOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - assertTrue(highlightedPositions.get(3).size() == 0); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition arg = d.addArgument("arg", "ftft"); + final CounterExampleUnaryOperator next = new CounterExampleNext( + d.getCounterExample(), arg); + + d.checkValues("next", next, "tftf"); + + d.expectedHighlight(0, "nextH", 1); + d.expectedHighlight(1, "nextH", 2); + d.expectedHighlight(2, "nextH", 3); + d.expectedHighlight(3, "nextH"); + d.checkHighlights("next", next, "nextH"); } @Test public void testNextOnInfinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create an argument - CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); - - // create an operator - CounterExampleUnaryOperator nextOperator = new CounterExampleNext( - PathType.INFINITE, 0, argument); - - // check result values - List<CounterExampleValueType> values = nextOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> highlightedPositions = nextOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 1 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); - - // create an operator - nextOperator = new CounterExampleNext(PathType.INFINITE, 1, argument); - - // check result values - values = nextOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - highlightedPositions = nextOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - - // Loop entry = 2 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); - - // create an operator - nextOperator = new CounterExampleNext(PathType.INFINITE, 2, argument); - - // check result values - values = nextOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = nextOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - - // Loop entry = 3 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); - - // create an operator - nextOperator = new CounterExampleNext(PathType.INFINITE, 3, argument); - - // check result values - values = nextOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - highlightedPositions = nextOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + final String[] values = new String[] { "tftf", "tftt", "tftf", "tftt" }; + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + final CounterExampleProposition arg = d.addArgument("arg", "ftft"); + final CounterExampleUnaryOperator next = new CounterExampleNext( + d.getCounterExample(), arg); + + d.checkValues("next", next, values[entry]); + d.expectedHighlight(0, "nextH", 1); + d.expectedHighlight(1, "nextH", 2); + d.expectedHighlight(2, "nextH", 3); + d.expectedHighlight(3, "nextH", entry); + d.checkHighlights("next", next, "nextH"); + } } @Test public void testNextOnReducedPath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator nextOperator = new CounterExampleNext( - PathType.REDUCED, -1, argument); - - // check result values - final List<CounterExampleValueType> values = nextOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = nextOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - assertTrue(highlightedPositions.get(3).size() == 0); + final LtlTestDescription d = LtlTestDescription.reduced(4); + final CounterExampleProposition arg = d.addArgument("arg", "tuft"); + final CounterExampleUnaryOperator next = new CounterExampleNext( + d.getCounterExample(), arg); + d.checkValues("next", next, "uftu"); + + d.expectedHighlight(0, "nextH", 1); + d.expectedHighlight(1, "nextH", 2); + d.expectedHighlight(2, "nextH", 3); + d.expectedHighlight(3, "nextH"); + d.checkHighlights("next", next, "nextH"); } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java index b7d9d7e034b5b9f692d5b6aa13f8a017f1717d6c..8eeb19f6093b901aea5a63b98946846d1388245b 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleNotUnitTest.java @@ -1,18 +1,10 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; import de.prob.core.domainobjects.ltl.CounterExampleNegation; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for a "not" operator. @@ -27,57 +19,8 @@ public final class CounterExampleNotUnitTest { */ @Test public void testNotOnFinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, argumentValues); - - // create an operator - final CounterExampleUnaryOperator notOperator = new CounterExampleNegation( - PathType.FINITE, argument); - - // check result values - final List<CounterExampleValueType> values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - // State 0 - final List<List<Integer>> highlightedPositions = notOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + final LtlTestDescription d = LtlTestDescription.finite(4); + checkNot(d); } /* @@ -85,191 +28,10 @@ public final class CounterExampleNotUnitTest { */ @Test public void testNotOnInFinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create argument - CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); - - // create an operator - CounterExampleUnaryOperator notOperator = new CounterExampleNegation( - PathType.INFINITE, 0, argument); - - // check result values - List<CounterExampleValueType> values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> highlightedPositions = notOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - // State 0 - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 1 - // create argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); - - // create an operator - notOperator = new CounterExampleNegation(PathType.INFINITE, 1, argument); - - // check result values - values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = notOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - // State 0 - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 2 - // create argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); - - // create an operator - notOperator = new CounterExampleNegation(PathType.INFINITE, 2, argument); - - // check result values - values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = notOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - // State 0 - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 3 - // create argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); - - // create an operator - notOperator = new CounterExampleNegation(PathType.INFINITE, 3, argument); - - // check result values - values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = notOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - // State 0 - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + checkNot(d); + } } /* @@ -277,57 +39,8 @@ public final class CounterExampleNotUnitTest { */ @Test public void testNotOnReducedPath1() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, argumentValues); - - // create an operator - final CounterExampleUnaryOperator notOperator = new CounterExampleNegation( - PathType.REDUCED, argument); - - // check result values - final List<CounterExampleValueType> values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - // State 0 - final List<List<Integer>> highlightedPositions = notOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + checkNot(d); } /* @@ -335,56 +48,27 @@ public final class CounterExampleNotUnitTest { */ @Test public void testNotOnReducedPath2() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, argumentValues); - - // create an operator - final CounterExampleUnaryOperator notOperator = new CounterExampleNegation( - PathType.REDUCED, argument); - - // check result values - final List<CounterExampleValueType> values = notOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - // State 0 - final List<List<Integer>> highlightedPositions = notOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + final CounterExampleProposition arg = d.addArgument("not", "tufu"); + final CounterExampleUnaryOperator not = new CounterExampleNegation( + d.getCounterExample(), arg); + d.checkValues("not", not, "futu"); + d.expectedHighlight(0, "notH", 0); + d.expectedHighlight(1, "notH", 1); + d.expectedHighlight(2, "notH", 2); + d.expectedHighlight(3, "notH", 3); + d.checkHighlights("not", not, "notH"); + } - // State 3 - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + private void checkNot(final LtlTestDescription d) { + final CounterExampleProposition arg = d.addArgument("not", "tfft"); + final CounterExampleUnaryOperator not = new CounterExampleNegation( + d.getCounterExample(), arg); + d.checkValues("not", not, "fttf"); + d.expectedHighlight(0, "notH", 0); + d.expectedHighlight(1, "notH", 1); + d.expectedHighlight(2, "notH", 2); + d.expectedHighlight(3, "notH", 3); + d.checkHighlights("not", not, "notH"); } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java index 705ef839a8f48d6cce8e1458a2a32463d193025b..33229e73fe06c46044480552116c416c70b6fd73 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOnceUnitTest.java @@ -1,18 +1,10 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; import de.prob.core.domainobjects.ltl.CounterExampleOnce; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for an "once" operator. @@ -26,53 +18,8 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceTrueDefinitionOnFinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.FINITE, argument); - - // check result values - final List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + final LtlTestDescription d = LtlTestDescription.finite(4); + checkOnce(d); } /* @@ -80,225 +27,19 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceFalseDefinitionOnFinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.FINITE, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.FINITE, -1, argument); - - // check result values - final List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); + final LtlTestDescription d = LtlTestDescription.finite(4); + checkOnceCompleteFalse(d); } /* - * f-TFTF, O f-FTTT + * f-FTFT, O f-FTTT */ @Test public void testOnceTrueDefinitionOnInfinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create an argument - CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); - - // create an operator - CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.INFINITE, 0, argument); - - // check result values - List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 1 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); - - // create an operator - onceOperator = new CounterExampleOnce(PathType.INFINITE, 1, argument); - - // check result values - values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - highlightedPositions = onceOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 2 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); - - // create an operator - onceOperator = new CounterExampleOnce(PathType.INFINITE, 2, argument); - - // check result values - values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - highlightedPositions = onceOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 3 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); - - // create an operator - onceOperator = new CounterExampleOnce(PathType.INFINITE, 3, argument); - - // check result values - values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - highlightedPositions = onceOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + checkOnce(d); + } } /* @@ -306,171 +47,10 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceFalseDefinitionOnInfinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create an argument - CounterExampleProposition argument = new CounterExamplePredicate("", - PathType.INFINITE, 0, argumentValues); - - // create an operator - CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.INFINITE, 0, argument); - - // check result values - List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 1 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 1, - argumentValues); - - // create an operator - onceOperator = new CounterExampleOnce(PathType.INFINITE, 1, argument); - - // check result values - values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = onceOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 2 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 2, - argumentValues); - - // create an operator - onceOperator = new CounterExampleOnce(PathType.INFINITE, 2, argument); - - // check result values - values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = onceOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 3 - // create an argument - argument = new CounterExamplePredicate("", PathType.INFINITE, 3, - argumentValues); - - // create an operator - onceOperator = new CounterExampleOnce(PathType.INFINITE, 3, argument); - - // check result values - values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = onceOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + checkOnceCompleteFalse(d); + } } /* @@ -478,53 +58,8 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceTrueDefinitionOnReducedPath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.REDUCED, -1, argument); - - // check result values - final List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + checkOnce(d); } /* @@ -532,53 +67,8 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceFalseDefinitionOnReducedPath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.REDUCED, -1, argument); - - // check result values - final List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + checkOnceCompleteFalse(d); } /* @@ -586,53 +76,16 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceUnknownDefinitionOnReducedPath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.REDUCED, -1, argument); - - // check result values - final List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - assertTrue(highlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - assertTrue(highlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + final CounterExampleProposition arg = d.addArgument("arg", "ufuf"); + final CounterExampleUnaryOperator once = new CounterExampleOnce( + d.getCounterExample(), arg); + d.checkValues("once", once, "uuuu"); + d.expectedHighlight(0, "onceH", 0); + d.expectedHighlight(1, "onceH", 0, 1); + d.expectedHighlight(2, "onceH", 0, 1, 2); + d.expectedHighlight(3, "onceH", 0, 1, 2, 3); + d.checkHighlights("once", once, "onceH"); } /* @@ -640,52 +93,39 @@ public final class CounterExampleOnceUnitTest { */ @Test public void testOnceOnReducedPath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, argumentValues); - - // create an operator - final CounterExampleUnaryOperator onceOperator = new CounterExampleOnce( - PathType.REDUCED, -1, argument); - - // check result values - final List<CounterExampleValueType> values = onceOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = onceOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - assertTrue(highlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + final CounterExampleProposition arg = d.addArgument("arg", "futu"); + final CounterExampleUnaryOperator once = new CounterExampleOnce( + d.getCounterExample(), arg); + d.checkValues("once", once, "futt"); + d.expectedHighlight(0, "onceH", 0); + d.expectedHighlight(1, "onceH", 0, 1); + d.expectedHighlight(2, "onceH", 2); + d.expectedHighlight(3, "onceH", 2); + d.checkHighlights("once", once, "onceH"); + } - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); + private void checkOnce(final LtlTestDescription d) { + final CounterExampleProposition arg = d.addArgument("arg", "ftft"); + final CounterExampleUnaryOperator once = new CounterExampleOnce( + d.getCounterExample(), arg); + d.checkValues("once", once, "fttt"); + d.expectedHighlight(0, "onceH", 0); + d.expectedHighlight(1, "onceH", 1); + d.expectedHighlight(2, "onceH", 1); + d.expectedHighlight(3, "onceH", 3); + d.checkHighlights("once", once, "onceH"); + } - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); + private void checkOnceCompleteFalse(final LtlTestDescription d) { + final CounterExampleProposition arg = d.addArgument("arg", "ffff"); + final CounterExampleUnaryOperator once = new CounterExampleOnce( + d.getCounterExample(), arg); + d.checkValues("once", once, "ffff"); + d.expectedHighlight(0, "onceH", 0); + d.expectedHighlight(1, "onceH", 0, 1); + d.expectedHighlight(2, "onceH", 0, 1, 2); + d.expectedHighlight(3, "onceH", 0, 1, 2, 3); + d.checkHighlights("once", once, "onceH"); } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java index 22f082787feaea19928837bc4ec0cdf31716aa96..ba5f5ad113bfca8d2d8cb427a6d5152e571b429f 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleOrUnitTest.java @@ -7,7 +7,7 @@ import java.util.List; import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; import de.prob.core.domainobjects.ltl.CounterExampleDisjunction; import de.prob.core.domainobjects.ltl.CounterExamplePredicate; @@ -42,17 +42,19 @@ public final class CounterExampleOrUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.finite(4); + // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction( - PathType.FINITE, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = orOperator.getValues(); @@ -127,17 +129,18 @@ public final class CounterExampleOrUnitTest { CounterExampleValueType.FALSE }); // Loop entry = 0 + final CounterExample ce0 = TestCounterExample.loop(0, 4); // create first argument CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); + "", ce0, firstArgumentValues); // create second argument CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); + "", ce0, secondArgumentValues); // create an operator CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction( - PathType.INFINITE, 0, firstArgument, secondArgument); + ce0, firstArgument, secondArgument); // check result values List<CounterExampleValueType> values = orOperator.getValues(); @@ -190,17 +193,19 @@ public final class CounterExampleOrUnitTest { new Integer[] { 3 })); // Loop entry = 1 + final CounterExample ce1 = TestCounterExample.loop(1, 4); + // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + firstArgument = new CounterExamplePredicate("", ce1, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + secondArgument = new CounterExamplePredicate("", ce1, secondArgumentValues); // create an operator - orOperator = new CounterExampleDisjunction(PathType.INFINITE, 1, - firstArgument, secondArgument); + orOperator = new CounterExampleDisjunction(ce1, firstArgument, + secondArgument); // check result values values = orOperator.getValues(); @@ -251,17 +256,18 @@ public final class CounterExampleOrUnitTest { new Integer[] { 3 })); // Loop entry = 2 + final CounterExample ce2 = TestCounterExample.loop(2, 4); // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + firstArgument = new CounterExamplePredicate("", ce2, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + secondArgument = new CounterExamplePredicate("", ce2, secondArgumentValues); // create an operator - orOperator = new CounterExampleDisjunction(PathType.INFINITE, 2, - firstArgument, secondArgument); + orOperator = new CounterExampleDisjunction(ce2, firstArgument, + secondArgument); // check result values values = orOperator.getValues(); @@ -312,17 +318,18 @@ public final class CounterExampleOrUnitTest { new Integer[] { 3 })); // Loop entry = 3 + final CounterExample ce3 = TestCounterExample.loop(3, 4); // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + firstArgument = new CounterExamplePredicate("", ce3, firstArgumentValues); // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + secondArgument = new CounterExamplePredicate("", ce3, secondArgumentValues); // create an operator - orOperator = new CounterExampleDisjunction(PathType.INFINITE, 3, - firstArgument, secondArgument); + orOperator = new CounterExampleDisjunction(ce3, firstArgument, + secondArgument); // check result values values = orOperator.getValues(); @@ -394,17 +401,19 @@ public final class CounterExampleOrUnitTest { CounterExampleValueType.FALSE, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); + // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = orOperator.getValues(); @@ -478,17 +487,18 @@ public final class CounterExampleOrUnitTest { CounterExampleValueType.UNKNOWN, CounterExampleValueType.FALSE }); + final CounterExample ce = TestCounterExample.reduced(4); // create first argument final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); + "", ce, firstArgumentValues); // create second argument final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); + "", ce, secondArgumentValues); // create an operator final CounterExampleBinaryOperator orOperator = new CounterExampleDisjunction( - PathType.REDUCED, firstArgument, secondArgument); + ce, firstArgument, secondArgument); // check result values final List<CounterExampleValueType> values = orOperator.getValues(); diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java index bbc587681fdca7093b97ee8536134f095803d2ed..c9160c73629adef9122bcccdcca0fda064a94e53 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleReleaseUnitTest.java @@ -1,18 +1,10 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; import de.prob.core.domainobjects.ltl.CounterExampleRelease; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for a "release" operator. @@ -26,93 +18,26 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseTrueDefinitionOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "ffft"); + final CounterExampleProposition snd = d.addArgument("snd", "tttt"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "tttt"); - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); + d.expectedHighlight(0, "fstH", 3); + d.expectedHighlight(0, "sndH", 0, 1, 2, 3); - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.FINITE, firstArgument, secondArgument); + d.expectedHighlight(1, "fstH", 3); + d.expectedHighlight(1, "sndH", 1, 2, 3); - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); + d.expectedHighlight(2, "fstH", 3); + d.expectedHighlight(2, "sndH", 2, 3); - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); + d.expectedHighlight(3, "fstH", 3); + d.expectedHighlight(3, "sndH", 3); - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); } /* @@ -120,81 +45,26 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseTrueDefinitionOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "ffff"); + final CounterExampleProposition snd = d.addArgument("snd", "tttt"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "tttt"); - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); + d.expectedHighlight(0, "fstH"); + d.expectedHighlight(0, "sndH", 0, 1, 2, 3); - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); + d.expectedHighlight(1, "fstH"); + d.expectedHighlight(1, "sndH", 1, 2, 3); - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.FINITE, firstArgument, secondArgument); + d.expectedHighlight(2, "fstH"); + d.expectedHighlight(2, "sndH", 2, 3); - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); + d.expectedHighlight(3, "fstH"); + d.expectedHighlight(3, "sndH", 3); - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); } /* @@ -202,90 +72,26 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseFalseDefinitionOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "ffft"); + final CounterExampleProposition snd = d.addArgument("snd", "tttf"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "ffff"); - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.FINITE, firstArgument, secondArgument); + d.expectedHighlight(0, "fstH", 0, 1, 2); + d.expectedHighlight(0, "sndH", 3); - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); + d.expectedHighlight(1, "fstH", 1, 2); + d.expectedHighlight(1, "sndH", 3); - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); + d.expectedHighlight(2, "fstH", 2); + d.expectedHighlight(2, "sndH", 3); - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); + d.expectedHighlight(3, "fstH"); + d.expectedHighlight(3, "sndH", 3); - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); } /* @@ -293,90 +99,26 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseFalseDefinitionOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "ffff"); + final CounterExampleProposition snd = d.addArgument("snd", "tttf"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "ffff"); - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); + d.expectedHighlight(0, "fstH", 0, 1, 2); + d.expectedHighlight(0, "sndH", 3); - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); + d.expectedHighlight(1, "fstH", 1, 2); + d.expectedHighlight(1, "sndH", 3); - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); + d.expectedHighlight(2, "fstH", 2); + d.expectedHighlight(2, "sndH", 3); - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); + d.expectedHighlight(3, "fstH"); + d.expectedHighlight(3, "sndH", 3); - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); } /* @@ -384,84 +126,26 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "tftf"); + final CounterExampleProposition snd = d.addArgument("snd", "tfft"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "tfft"); - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); + d.expectedHighlight(0, "fstH", 0); + d.expectedHighlight(0, "sndH", 0); - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, -1, firstArgumentValues); + d.expectedHighlight(1, "fstH"); + d.expectedHighlight(1, "sndH", 1); - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, -1, secondArgumentValues); + d.expectedHighlight(2, "fstH"); + d.expectedHighlight(2, "sndH", 2); - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.FINITE, -1, firstArgument, secondArgument); + d.expectedHighlight(3, "fstH"); + d.expectedHighlight(3, "sndH", 3); - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); } /* @@ -469,87 +153,26 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, -1, firstArgumentValues); + final LtlTestDescription d = LtlTestDescription.finite(4); + final CounterExampleProposition fst = d.addArgument("fst", "fttf"); + final CounterExampleProposition snd = d.addArgument("snd", "tftt"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "fftt"); - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, -1, secondArgumentValues); + d.expectedHighlight(0, "fstH", 0); + d.expectedHighlight(0, "sndH", 1); - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.FINITE, -1, firstArgument, secondArgument); + d.expectedHighlight(1, "fstH"); + d.expectedHighlight(1, "sndH", 1); - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); + d.expectedHighlight(2, "fstH", 2); + d.expectedHighlight(2, "sndH", 2); - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); + d.expectedHighlight(3, "fstH"); + d.expectedHighlight(3, "sndH", 3); - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); } /* @@ -557,309 +180,28 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseTrueDefinitionOnInfinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + final CounterExampleProposition fst = d.addArgument("fst", "ffft"); + final CounterExampleProposition snd = d.addArgument("snd", "tttt"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "tttt"); - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); + d.expectedHighlight(0, "fstH", 3); + d.expectedHighlight(0, "sndH", 0, 1, 2, 3); - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.expectedHighlight(1, "fstH", 3); + d.expectedHighlight(1, "sndH", 1, 2, 3); - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); + d.expectedHighlight(2, "fstH", 3); + d.expectedHighlight(2, "sndH", 2, 3); - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); + d.expectedHighlight(3, "fstH", 3); + d.expectedHighlight(3, "sndH", 3); - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); + } } /* @@ -867,2622 +209,2448 @@ public final class CounterExampleReleaseUnitTest { */ @Test public void testReleaseTrueDefinitionOnInfinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3, 0, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 0, 1, 2 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 1, 2 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFT, g-TTTF, f R g-FFFF - */ - @Test - public void testReleaseFalseDefinitionOnInfinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + final CounterExampleProposition fst = d.addArgument("fst", "ffff"); + final CounterExampleProposition snd = d.addArgument("snd", "tttt"); + final CounterExampleBinaryOperator release = new CounterExampleRelease( + d.getCounterExample(), fst, snd); + d.checkValues("release", release, "tttt"); - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.expectedHighlight(0, "fstH"); + d.expectedHighlight(0, "sndH", 0, 1, 2, 3); - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); + d.expectedHighlight(1, "fstH"); + d.expectedHighlight(1, "sndH", future(1, 4, entry)); - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); + d.expectedHighlight(2, "fstH"); + d.expectedHighlight(2, "sndH", future(2, 4, entry)); - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, - firstArgument, secondArgument); + d.expectedHighlight(3, "fstH"); + d.expectedHighlight(3, "sndH", future(3, 4, entry)); - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFF, g-TTTF, f R g-FFFF - */ - @Test - public void testReleaseFalseDefinitionOnInfinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + d.checkHighlights("release", release, "fstH", "sndH"); + } } - /* - * f-TFTF, g-TFFT, f R g-TFFT - */ - @Test - public void testReleaseOnInfinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = releaseOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); + // /* + // * f-FFFT, g-TTTF, f R g-FFFF + // */ + // @Test + // public void testReleaseFalseDefinitionOnInfinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFFF, g-TTTF, f R g-FFFF + // */ + // @Test + // public void testReleaseFalseDefinitionOnInfinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TFTF, g-TFFT, f R g-TFFT + // */ + // @Test + // public void testReleaseOnInfinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // releaseOperator = new CounterExampleRelease(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = releaseOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUUT, g-TTTT, f R g-TTTT + // */ + // @Test + // public void testReleaseTrueDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFFF, g-TTTT, f R g-UUUU + // */ + // @Test + // public void testReleaseTrueDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFFT, g-TTTF, f R g-FFFF + // */ + // @Test + // public void testReleaseFalseDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFFF, g-FTTT, f R g-FUUU + // */ + // @Test + // public void testReleaseFalseDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FUTU, g-UTUU, f R g-UTTU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FUUU, g-UTFU, f R g-UUFU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FUUU, g-UTUU, f R g-UUUU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFFF, g-TTTT, f R g-UUUU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath4() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFFF, g-UUUU, f R g-UUUU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath5() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUUU, g-UUUU, f R g-UUUU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath6() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUTF, g-FTTT, f R g-FTTU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath7() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FUTU, g-TUTU, f R g-UUTU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath8() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FFTU, g-TUTU, f R g-UUTU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath9() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FUUU, g-UTFU, f R g-UUFU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath10() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FUUU, g-UUFU, f R g-UUFU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath11() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FTUF, g-FTUU, f R g-FTUU + // */ + // @Test + // public void testReleaseUnknownDefinitionOnReducedPath12() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator releaseOperator = new + // CounterExampleRelease( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = releaseOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = releaseOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = releaseOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + + private static int[] future(int current, int size, int entry) { + final int first = current <= entry ? current : entry; + final int resSize = size - first; + int[] res = new int[resSize]; + for (int i = 0; i < resSize; i++) { + res[i] = first + i; + } + return res; } - /* - * f-UUUT, g-TTTT, f R g-TTTT - */ - @Test - public void testReleaseTrueDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFF, g-TTTT, f R g-UUUU - */ - @Test - public void testReleaseTrueDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFT, g-TTTF, f R g-FFFF - */ - @Test - public void testReleaseFalseDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFF, g-FTTT, f R g-FUUU - */ - @Test - public void testReleaseFalseDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FUTU, g-UTUU, f R g-UTTU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FUUU, g-UTFU, f R g-UUFU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FUUU, g-UTUU, f R g-UUUU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFF, g-TTTT, f R g-UUUU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath4() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFFF, g-UUUU, f R g-UUUU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath5() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UUUU, g-UUUU, f R g-UUUU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath6() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UUTF, g-FTTT, f R g-FTTU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath7() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FUTU, g-TUTU, f R g-UUTU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath8() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - assertTrue(secondHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FFTU, g-TUTU, f R g-UUTU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath9() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FUUU, g-UTFU, f R g-UUFU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath10() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FUUU, g-UUFU, f R g-UUFU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath11() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - assertTrue(secondHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FTUF, g-FTUU, f R g-FTUU - */ - @Test - public void testReleaseUnknownDefinitionOnReducedPath12() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator releaseOperator = new CounterExampleRelease( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = releaseOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = releaseOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = releaseOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java index d41d7a2918a41f56474509b8567db88188b2ba13..967f926419d1ce9f784d37d9830cc00394ecfa26 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleSinceUnitTest.java @@ -1,18 +1,5 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - -import org.junit.Test; - -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; -import de.prob.core.domainobjects.ltl.CounterExampleProposition; -import de.prob.core.domainobjects.ltl.CounterExampleSince; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for a "since" operator. @@ -21,3224 +8,3293 @@ import de.prob.core.domainobjects.ltl.CounterExampleValueType; * */ public final class CounterExampleSinceUnitTest { - /* - * f-FTTT, g-TFFF, f S g-TTTT - */ - @Test - public void testSinceTrueDefinitionOnFinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FFTT, g-TFFF, f S g-TFFF - */ - @Test - public void testSinceFalseDefinitionOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-FTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceFalseDefinitionOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceFalseDefinitionOnFinitePath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f - TFFT g - FTFF f S g - FTFF - */ - @Test - public void testSinceOnFinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - } - - /* - * f-FTTT, g-TFFF, f S g-TTTT - */ - @Test - public void testSinceTrueDefinitionOnInfinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FFTT, g-TFFF, f S g-TFFF - */ - @Test - public void testSinceFalseDefinitionOnInfinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-FTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceFalseDefinitionOnInfinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceFalseDefinitionOnInfinitePath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-FTTT, g-TFFF, f S g-TTTT - */ - @Test - public void testSinceTrueDefinitionOnReducedPath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FFTT, g-TFFF, f S g-TFFF - */ - @Test - public void testSinceFalseDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-FTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceFalseDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceFalseDefinitionOnReducedPath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-UUTU, g-UTUF, f S g-UTTU - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-UFUU, g-UUFF, f S g-UUUU - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-UUTU, g-UUUF, f S g-UUUU - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-TTTT, g-FFFF, f S g-FFFF - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath4() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TTTT, g-UUUU, f S g-UUUU - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath5() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - // f-TUTU, g-UFUF, f S g-UUUU - @Test - public void testSinceUnknownDefinitionOnReducedPath6() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - // f-UFTU, g-FFTF, f S g-UFTU - @Test - public void testSinceUnknownDefinitionOnReducedPath7() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - } - - // f-UUUU, g-TUUU, f S g-TUUU - @Test - public void testSinceUnknownDefinitionOnReducedPath8() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUFU, g-TUFU, f S g- TUFU - @Test - public void testSinceUnknownDefinitionOnReducedPath9() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-FFUU, g-FUUU, f S g-FUUU - @Test - public void testSinceUnknownDefinitionOnReducedPath10() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUUU, g-UTUU, f S g-UTUU - @Test - public void testSinceUnknownDefinitionOnReducedPath11() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UFUU, g-UUUU, f S g-UUUU - @Test - public void testSinceUnknownDefinitionOnReducedPath12() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UFTU, g-FFTF, f S g-UFTU - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath13() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - } - - /* - * f-UUUU, g-UUUU, f S g-UUUU - */ - @Test - public void testSinceUnknownDefinitionOnReducedPath14() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = sinceOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = sinceOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = sinceOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } + // /* + // * f-FTTT, g-TFFF, f S g-TTTT + // */ + // @Test + // public void testSinceTrueDefinitionOnFinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FFTT, g-TFFF, f S g-TFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnFinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-FTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnFinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnFinitePath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f - TFFT g - FTFF f S g - FTFF + // */ + // @Test + // public void testSinceOnFinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // } + // + // /* + // * f-FTTT, g-TFFF, f S g-TTTT + // */ + // @Test + // public void testSinceTrueDefinitionOnInfinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FFTT, g-TFFF, f S g-TFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnInfinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-FTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnInfinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnInfinitePath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator sinceOperator = new CounterExampleSince( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // sinceOperator = new CounterExampleSince(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-FTTT, g-TFFF, f S g-TTTT + // */ + // @Test + // public void testSinceTrueDefinitionOnReducedPath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FFTT, g-TFFF, f S g-TFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-FTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceFalseDefinitionOnReducedPath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-UUTU, g-UTUF, f S g-UTTU + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-UFUU, g-UUFF, f S g-UUUU + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-UUTU, g-UUUF, f S g-UUUU + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f S g-FFFF + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath4() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TTTT, g-UUUU, f S g-UUUU + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath5() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // // f-TUTU, g-UFUF, f S g-UUUU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath6() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // // f-UFTU, g-FFTF, f S g-UFTU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath7() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // } + // + // // f-UUUU, g-TUUU, f S g-TUUU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath8() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUFU, g-TUFU, f S g- TUFU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath9() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-FFUU, g-FUUU, f S g-FUUU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath10() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUUU, g-UTUU, f S g-UTUU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath11() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UFUU, g-UUUU, f S g-UUUU + // @Test + // public void testSinceUnknownDefinitionOnReducedPath12() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UFTU, g-FFTF, f S g-UFTU + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath13() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // } + // + // /* + // * f-UUUU, g-UUUU, f S g-UUUU + // */ + // @Test + // public void testSinceUnknownDefinitionOnReducedPath14() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator sinceOperator = new + // CounterExampleSince( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = sinceOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = sinceOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = sinceOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java index 8726fa19ecabd2e3593d70e6c0fd2a8e45a4394d..45bc1d3d5c0258adbbfb1d2d38e29e6870a231cc 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleTriggerUnitTest.java @@ -1,18 +1,5 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - -import org.junit.Test; - -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; -import de.prob.core.domainobjects.ltl.CounterExampleProposition; -import de.prob.core.domainobjects.ltl.CounterExampleTrigger; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for a "trigger" operator. @@ -21,3432 +8,3496 @@ import de.prob.core.domainobjects.ltl.CounterExampleValueType; * */ public final class CounterExampleTriggerUnitTest { - /* - * f-TFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerTrueDefinitionOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-FFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerTrueDefinitionOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TFFF, g-FTTT, f T g-FFFF - */ - @Test - public void testTriggerFalseDefinitionOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FFFF, g-FTTT, f T g-FFFF - */ - @Test - public void testTriggerFalseDefinitionOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FTFT, g-TFFT, f T g-TFFT - */ - @Test - public void testTriggerOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FTTF, g-TTFT, f T g-TTFF - */ - @Test - public void testTriggerOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.FINITE, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - } - - /* - * f-TFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerTrueDefinitionOnInfinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-FFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerTrueDefinitionOnInfinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TFFF, g-FTTT, f T g-FFFF - */ - @Test - public void testTriggerFalseDefinitionOnInfinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FFFF, g-FTTT, f T g-FFFF - */ - @Test - public void testTriggerFalseDefinitionOnInfinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FTFT, g-TFFT, f T g-TFFT - */ - @Test - public void testTriggerOnInfinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = triggerOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerTrueDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-FFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerTrueDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-TFFF, g-FTTT, f T g-FFFF - */ - @Test - public void testTriggerFalseDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-FFFF, g-FTTT, f T g-FFFF - */ - @Test - public void testTriggerFalseDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - } - - /* - * f-UTUF, g-UUTU, f T g-UTTU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-UUUF, g-UFTU, f T g-UFFU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-UUUF, g-UUTU, f T g-UUUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-FFFF, g-TTTT, f T g-TTTT - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath4() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-FFFF, g-UUUU, f T g-UUUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath5() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 0 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1, 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1, 0 })); - } - - /* - * f-UUUU, g-UUUU, f T g-UUUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath6() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-FTUU, g-TTTF, f T g-TTTF - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath7() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUF, g-UTUT, f T g-UTUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath8() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - } - - /* - * f-UTFF, g-UTUT, f T g-UTUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath9() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-UUUF, g-UFTU, f T g-UFUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath10() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2, 1 })); - } - - /* - * f-UUUF, g-UFUU, f T g-UFUU - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath11() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - } - - /* - * f-FUTF, g-UUTF, f T g-UUTF - */ - @Test - public void testTriggerUnknownDefinitionOnReducedPath12() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = triggerOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = triggerOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = triggerOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } + // /* + // * f-TFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerTrueDefinitionOnFinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-FFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerTrueDefinitionOnFinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TFFF, g-FTTT, f T g-FFFF + // */ + // @Test + // public void testTriggerFalseDefinitionOnFinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FFFF, g-FTTT, f T g-FFFF + // */ + // @Test + // public void testTriggerFalseDefinitionOnFinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FTFT, g-TFFT, f T g-TFFT + // */ + // @Test + // public void testTriggerOnFinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FTTF, g-TTFT, f T g-TTFF + // */ + // @Test + // public void testTriggerOnFinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.FINITE, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 2 })); + // } + // + // /* + // * f-TFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerTrueDefinitionOnInfinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-FFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerTrueDefinitionOnInfinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TFFF, g-FTTT, f T g-FFFF + // */ + // @Test + // public void testTriggerFalseDefinitionOnInfinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FFFF, g-FTTT, f T g-FFFF + // */ + // @Test + // public void testTriggerFalseDefinitionOnInfinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FTFT, g-TFFT, f T g-TFFT + // */ + // @Test + // public void testTriggerOnInfinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate(PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // triggerOperator = new CounterExampleTrigger(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = triggerOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerTrueDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-FFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerTrueDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-TFFF, g-FTTT, f T g-FFFF + // */ + // @Test + // public void testTriggerFalseDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-FFFF, g-FTTT, f T g-FFFF + // */ + // @Test + // public void testTriggerFalseDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // } + // + // /* + // * f-UTUF, g-UUTU, f T g-UTTU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-UUUF, g-UFTU, f T g-UFFU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-UUUF, g-UUTU, f T g-UUUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-FFFF, g-TTTT, f T g-TTTT + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath4() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-FFFF, g-UUUU, f T g-UUUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath5() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 0 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1, 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1, 0 })); + // } + // + // /* + // * f-UUUU, g-UUUU, f T g-UUUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath6() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-FTUU, g-TTTF, f T g-TTTF + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath7() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUF, g-UTUT, f T g-UTUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath8() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // } + // + // /* + // * f-UTFF, g-UTUT, f T g-UTUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath9() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-UUUF, g-UFTU, f T g-UFUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath10() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2, 1 })); + // } + // + // /* + // * f-UUUF, g-UFUU, f T g-UFUU + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath11() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator triggerOperator = new + // CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // } + // + // /* + // * f-FUTF, g-UUTF, f T g-UUTF + // */ + // @Test + // public void testTriggerUnknownDefinitionOnReducedPath12() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator triggerOperator = new CounterExampleTrigger( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = triggerOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = triggerOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = triggerOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java index 1e7e0a7b5bf586f945c8d80ce7663d29f92c27de..f94c169e5c6fd88020decff033c4368f33660e9f 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleUntilUnitTest.java @@ -1,18 +1,5 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - -import org.junit.Test; - -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; -import de.prob.core.domainobjects.ltl.CounterExampleProposition; -import de.prob.core.domainobjects.ltl.CounterExampleUntil; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; /** * Unit test for an "until" operator. @@ -21,2286 +8,2352 @@ import de.prob.core.domainobjects.ltl.CounterExampleValueType; * */ public final class CounterExampleUntilUnitTest { - /* - * f-TTTF, g-FFFT, f U g-TTTT - */ - @Test - public void testUntilTrueDefinitionOnFinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTF, g-FFFF, f U g-FFFF - */ - @Test - public void testUntilFalseDefinitionOnFinitePath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTFF, g-FFFT, f U g-FFFT - */ - @Test - public void testUntilFalseDefinitionOnFinitePath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTT, g-FFFF, f U g-FFFF - */ - @Test - public void testUntilFalseDefinitionOnFinitePath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - TFFT g - FTFF f U g - TTFF - */ - @Test - public void testUntilOnFinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - TFFT g - FTFF - */ - @Test - public void testUntilOnInfinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 0 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - untilOperator = new CounterExampleUntil(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - untilOperator = new CounterExampleUntil(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - untilOperator = new CounterExampleUntil(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTU, g-UUUT, f U g-TTTT - */ - @Test - public void testUntilTrueDefinitionOnReducedPath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UUFU, g-FFFT, f U g-FFFT - */ - @Test - public void testUntilFalseDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UUUF, g-FFFF, f U g-FFFF - */ - @Test - public void testUntilFalseDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUU, g-FUTU, f U g-UTTU - */ - @Test - public void testUntilUnknownDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UUFU, g-FFUU, f U g-UUUU - */ - @Test - public void testUntilUnknownDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUU, g-FUUU, f U g-UUUU - */ - @Test - public void testUntilUnknownDefinitionOnReducedPath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTT, g-FFFF, f U g-UUUU - */ - @Test - public void testUntilUnknownDefinitionOnReducedPath4() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTT, g-UUUU, f U g-UUUU - */ - @Test - public void testUntilUnknownDefinitionOnReducedPath5() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUT, g-FUFU, f U g-UUUU - */ - @Test - public void testUntilOnReducedPathUnknownDefinition6() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTFU, g-FTFF, f U g-UTFU - */ - @Test - public void testUntilOnReducedPathUnknownDefinition7() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUUU, g-UUUT, f U g-UUUT - @Test - public void testUntilUnknownDefinitionOnReducedPath8() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UFUU, g-UFUT, f U g-UFUT - @Test - public void testUntilUnknownDefinitionOnReducedPath9() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUFF, g-UUUF, f U g-UUUF - @Test - public void testUntilUnknownDefinitionOnReducedPath10() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUUU, g-UUTU, f U g-UUTU - @Test - public void testUntilUnknownDefinitionOnReducedPath11() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUFU, g-UUUU, f U g-UUUU - @Test - public void testUntilUnknownDefinitionOnReducedPath12() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - UTFU g - FTFF f U g - UTFU - */ - @Test - public void testUntilOnReducedPathUnknownDefinition13() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - UUUU g - UUUU f U g - UUUU - */ - @Test - public void testUntilOnReducedPathUnknownDefinition14() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = untilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = untilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = untilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } + // /* + // * f-TTTF, g-FFFT, f U g-TTTT + // */ + // @Test + // public void testUntilTrueDefinitionOnFinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTF, g-FFFF, f U g-FFFF + // */ + // @Test + // public void testUntilFalseDefinitionOnFinitePath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTFF, g-FFFT, f U g-FFFT + // */ + // @Test + // public void testUntilFalseDefinitionOnFinitePath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f U g-FFFF + // */ + // @Test + // public void testUntilFalseDefinitionOnFinitePath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - TFFT g - FTFF f U g - TTFF + // */ + // @Test + // public void testUntilOnFinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - TFFT g - FTFF + // */ + // @Test + // public void testUntilOnInfinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator untilOperator = new CounterExampleUntil( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 0 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // untilOperator = new CounterExampleUntil(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // untilOperator = new CounterExampleUntil(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // untilOperator = new CounterExampleUntil(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTU, g-UUUT, f U g-TTTT + // */ + // @Test + // public void testUntilTrueDefinitionOnReducedPath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUFU, g-FFFT, f U g-FFFT + // */ + // @Test + // public void testUntilFalseDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUUF, g-FFFF, f U g-FFFF + // */ + // @Test + // public void testUntilFalseDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUU, g-FUTU, f U g-UTTU + // */ + // @Test + // public void testUntilUnknownDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUFU, g-FFUU, f U g-UUUU + // */ + // @Test + // public void testUntilUnknownDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUU, g-FUUU, f U g-UUUU + // */ + // @Test + // public void testUntilUnknownDefinitionOnReducedPath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f U g-UUUU + // */ + // @Test + // public void testUntilUnknownDefinitionOnReducedPath4() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTT, g-UUUU, f U g-UUUU + // */ + // @Test + // public void testUntilUnknownDefinitionOnReducedPath5() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUT, g-FUFU, f U g-UUUU + // */ + // @Test + // public void testUntilOnReducedPathUnknownDefinition6() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTFU, g-FTFF, f U g-UTFU + // */ + // @Test + // public void testUntilOnReducedPathUnknownDefinition7() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUUU, g-UUUT, f U g-UUUT + // @Test + // public void testUntilUnknownDefinitionOnReducedPath8() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UFUU, g-UFUT, f U g-UFUT + // @Test + // public void testUntilUnknownDefinitionOnReducedPath9() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUFF, g-UUUF, f U g-UUUF + // @Test + // public void testUntilUnknownDefinitionOnReducedPath10() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUUU, g-UUTU, f U g-UUTU + // @Test + // public void testUntilUnknownDefinitionOnReducedPath11() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUFU, g-UUUU, f U g-UUUU + // @Test + // public void testUntilUnknownDefinitionOnReducedPath12() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - UTFU g - FTFF f U g - UTFU + // */ + // @Test + // public void testUntilOnReducedPathUnknownDefinition13() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - UUUU g - UUUU f U g - UUUU + // */ + // @Test + // public void testUntilOnReducedPathUnknownDefinition14() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator untilOperator = new + // CounterExampleUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = untilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = untilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = untilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java index d34fdc6c62a857834503910b379c40483b121801..db33abab5280f1fe13d283aec6c4e1a095dd5086 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleWeakUntilUnitTest.java @@ -1,18 +1,5 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - -import org.junit.Test; - -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.core.domainobjects.ltl.CounterExampleBinaryOperator; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; -import de.prob.core.domainobjects.ltl.CounterExampleProposition; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; -import de.prob.core.domainobjects.ltl.CounterExampleWeakUntil; /** * Unit test for a "weak until" operator. @@ -21,2111 +8,2172 @@ import de.prob.core.domainobjects.ltl.CounterExampleWeakUntil; * */ public final class CounterExampleWeakUntilUnitTest { - /* - * f-TTTF, g-FFFT, f WU g-TTTT - */ - @Test - public void testWeakUntilOnFinitePathTrueDefinition1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTT, g-FFFF, f WU g-TTTT - */ - @Test - public void testWeakUntilOnFinitePathTrueDefinition2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 0); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 0); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 0); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 0); - } - - /* - * f-TTTF, g-FFFF, f WU g-FFFF - */ - @Test - public void testWeakUntilOnFinitePathFalseDefinition1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTFF, g-FFFT, f WU g-FFFT - */ - @Test - public void testWeakUntilOnFinitePathFalseDefinition2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - FFTT g - TFFF f WU g - TFTT - */ - @Test - public void testWeakUntilOnFinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 0); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 0); - } - - /* - * f - FFTT g - TFFF - */ - @Test - public void testWeakUntilOnInfinitePath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // Loop entry = 0 - // create first argument - CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, firstArgumentValues); - - // create second argument - CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.INFINITE, 0, secondArgumentValues); - - // create an operator - CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.INFINITE, 0, firstArgument, secondArgument); - - // check result values - List<CounterExampleValueType> values = weakUntilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 0 })); - - // Loop entry = 1 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, - secondArgumentValues); - - // create an operator - weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 1, - firstArgument, secondArgument); - - // check result values - values = weakUntilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(2).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3, 1 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 1 })); - - // Loop entry = 2 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, - secondArgumentValues); - - // create an operator - weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 2, - firstArgument, secondArgument); - - // check result values - values = weakUntilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 0); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3, 2 })); - assertTrue(secondHighlightedPositions.get(3).size() == 0); - - // Loop entry = 3 - // create first argument - firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - firstArgumentValues); - - // create second argument - secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, - secondArgumentValues); - - // create an operator - weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 3, - firstArgument, secondArgument); - - // check result values - values = weakUntilOperator.getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 0); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 0); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 0); - } - - /* - * f-TTTU, g-UUUT, f WU g-TTTT - */ - @Test - public void testWeakUntilTrueDefinitionOnReducedPath() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.FINITE, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.FINITE, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.TRUE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUU, g-FUTU, f WU g-UTTU - */ - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath1() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UUFU, g-FFUU, f WU g-UUUU - */ - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath2() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUU, g-FUUU, f WU g-UUUU - */ - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath3() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - assertTrue(secondHighlightedPositions.get(0).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - assertTrue(secondHighlightedPositions.get(1).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTT, g-FFFF, f WU g-UUUU - */ - @Test - public void testWeakUntilOnReducedPathUnknownDefinition4() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-TTTT, g-UUUU, f WU g-UUUU - */ - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath5() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTUT, g-FUFU, f WU g-UUUU - */ - @Test - public void testWeakUntilOnReducedPathUnknownDefinition6() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(0).size() == 4); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1, 2, 3 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - assertTrue(secondHighlightedPositions.get(1).size() == 3); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1, 2, 3 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - assertTrue(secondHighlightedPositions.get(2).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2, 3 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f-UTFU, g-FTFF, f WU g-UTFU - */ - @Test - public void testWeakUntilOnReducedPathUnknownDefinition7() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUUU, g-UUUT, f WU g-UUUT - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath8() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UFUU, g-UFUT, f WU g-UFUT - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath9() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.TRUE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 0); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUFF, g-UUUF, f WU g-UUUF - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath10() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUUU, g-UUTU, f WU g-UUTU - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath11() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 0); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - // f-UUFU, g-UUUU, f WU g-UUUU - @Test - public void testWeakUntilUnknownDefinitionOnReducedPath12() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - PathType.REDUCED, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - PathType.REDUCED, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - UTFU g - FTFF f WU g - UTFU - */ - @Test - public void testWeakUntilOnReducedPathUnknownDefinition13() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.FALSE }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.FALSE); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 2); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0, 1 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 0); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } - - /* - * f - UUUU g - UUUU f WU g - UUUU - */ - @Test - public void testWeakUntilOnReducedPathUnknownDefinition14() { - // create first argument values - final List<CounterExampleValueType> firstArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create second argument values - final List<CounterExampleValueType> secondArgumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.UNKNOWN }); - - // create first argument - final CounterExampleProposition firstArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, firstArgumentValues); - - // create second argument - final CounterExampleProposition secondArgument = new CounterExamplePredicate( - "", PathType.REDUCED, -1, secondArgumentValues); - - // create an operator - final CounterExampleBinaryOperator weakUntilOperator = new CounterExampleWeakUntil( - PathType.REDUCED, -1, firstArgument, secondArgument); - - // check result values - final List<CounterExampleValueType> values = weakUntilOperator - .getValues(); - assertTrue(values.size() == firstArgumentValues.size()); - assertTrue(values.size() == secondArgumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); - - // check highlighted positions - final List<List<Integer>> firstHighlightedPositions = weakUntilOperator - .getFirstHighlightedPositions(); - final List<List<Integer>> secondHighlightedPositions = weakUntilOperator - .getSecondHighlightedPositions(); - assertTrue(firstHighlightedPositions.size() == firstArgumentValues - .size()); - assertTrue(secondHighlightedPositions.size() == secondArgumentValues - .size()); - - // State 0 - assertTrue(firstHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - assertTrue(secondHighlightedPositions.get(0).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(0).toArray(new Integer[0]), - new Integer[] { 0 })); - - // State 1 - assertTrue(firstHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - assertTrue(secondHighlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 1 })); - - // State 2 - assertTrue(firstHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - assertTrue(secondHighlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 2 })); - - // State 3 - assertTrue(firstHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - firstHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - assertTrue(secondHighlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - secondHighlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 3 })); - } + // /* + // * f-TTTF, g-FFFT, f WU g-TTTT + // */ + // @Test + // public void testWeakUntilOnFinitePathTrueDefinition1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f WU g-TTTT + // */ + // @Test + // public void testWeakUntilOnFinitePathTrueDefinition2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 0); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 0); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 0); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 0); + // } + // + // /* + // * f-TTTF, g-FFFF, f WU g-FFFF + // */ + // @Test + // public void testWeakUntilOnFinitePathFalseDefinition1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTFF, g-FFFT, f WU g-FFFT + // */ + // @Test + // public void testWeakUntilOnFinitePathFalseDefinition2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.FALSE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - FFTT g - TFFF f WU g - TFTT + // */ + // @Test + // public void testWeakUntilOnFinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 0); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 0); + // } + // + // /* + // * f - FFTT g - TFFF + // */ + // @Test + // public void testWeakUntilOnInfinitePath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // Loop entry = 0 + // // create first argument + // CounterExampleProposition firstArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, firstArgumentValues); + // + // // create second argument + // CounterExampleProposition secondArgument = new CounterExamplePredicate( + // "", PathType.INFINITE, 0, secondArgumentValues); + // + // // create an operator + // CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.INFINITE, 0, firstArgument, secondArgument); + // + // // check result values + // List<CounterExampleValueType> values = weakUntilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // Loop entry = 1 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 1, + // secondArgumentValues); + // + // // create an operator + // weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 1, + // firstArgument, secondArgument); + // + // // check result values + // values = weakUntilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3, 1 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 1 })); + // + // // Loop entry = 2 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 2, + // secondArgumentValues); + // + // // create an operator + // weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 2, + // firstArgument, secondArgument); + // + // // check result values + // values = weakUntilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 0); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3, 2 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 0); + // + // // Loop entry = 3 + // // create first argument + // firstArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // firstArgumentValues); + // + // // create second argument + // secondArgument = new CounterExamplePredicate("", PathType.INFINITE, 3, + // secondArgumentValues); + // + // // create an operator + // weakUntilOperator = new CounterExampleWeakUntil(PathType.INFINITE, 3, + // firstArgument, secondArgument); + // + // // check result values + // values = weakUntilOperator.getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 0); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 0); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 0); + // } + // + // /* + // * f-TTTU, g-UUUT, f WU g-TTTT + // */ + // @Test + // public void testWeakUntilTrueDefinitionOnReducedPath() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.FINITE, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.FINITE, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.TRUE); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUU, g-FUTU, f WU g-UTTU + // */ + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath1() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UUFU, g-FFUU, f WU g-UUUU + // */ + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath2() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUU, g-FUUU, f WU g-UUUU + // */ + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath3() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTT, g-FFFF, f WU g-UUUU + // */ + // @Test + // public void testWeakUntilOnReducedPathUnknownDefinition4() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-TTTT, g-UUUU, f WU g-UUUU + // */ + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath5() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTUT, g-FUFU, f WU g-UUUU + // */ + // @Test + // public void testWeakUntilOnReducedPathUnknownDefinition6() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 4); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1, 2, 3 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 3); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1, 2, 3 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2, 3 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f-UTFU, g-FTFF, f WU g-UTFU + // */ + // @Test + // public void testWeakUntilOnReducedPathUnknownDefinition7() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUUU, g-UUUT, f WU g-UUUT + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath8() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UFUU, g-UFUT, f WU g-UFUT + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath9() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.FALSE); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.TRUE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 0); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUFF, g-UUUF, f WU g-UUUF + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath10() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.FALSE); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUUU, g-UUTU, f WU g-UUTU + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath11() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.TRUE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 0); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // // f-UUFU, g-UUUU, f WU g-UUUU + // @Test + // public void testWeakUntilUnknownDefinitionOnReducedPath12() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // PathType.REDUCED, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - UTFU g - FTFF f WU g - UTFU + // */ + // @Test + // public void testWeakUntilOnReducedPathUnknownDefinition13() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.FALSE, + // CounterExampleValueType.TRUE, + // CounterExampleValueType.FALSE, + // CounterExampleValueType.FALSE }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.TRUE); + // assertTrue(values.get(2) == CounterExampleValueType.FALSE); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 2); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0, 1 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 0); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } + // + // /* + // * f - UUUU g - UUUU f WU g - UUUU + // */ + // @Test + // public void testWeakUntilOnReducedPathUnknownDefinition14() { + // // create first argument values + // final List<CounterExampleValueType> firstArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create second argument values + // final List<CounterExampleValueType> secondArgumentValues = Arrays + // .asList(new CounterExampleValueType[] { + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN, + // CounterExampleValueType.UNKNOWN }); + // + // // create first argument + // final CounterExampleProposition firstArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, firstArgumentValues); + // + // // create second argument + // final CounterExampleProposition secondArgument = new + // CounterExamplePredicate( + // "", PathType.REDUCED, -1, secondArgumentValues); + // + // // create an operator + // final CounterExampleBinaryOperator weakUntilOperator = new + // CounterExampleWeakUntil( + // PathType.REDUCED, -1, firstArgument, secondArgument); + // + // // check result values + // final List<CounterExampleValueType> values = weakUntilOperator + // .getValues(); + // assertTrue(values.size() == firstArgumentValues.size()); + // assertTrue(values.size() == secondArgumentValues.size()); + // assertTrue(values.get(0) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(1) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); + // assertTrue(values.get(3) == CounterExampleValueType.UNKNOWN); + // + // // check highlighted positions + // final List<List<Integer>> firstHighlightedPositions = weakUntilOperator + // .getFirstHighlightedPositions(); + // final List<List<Integer>> secondHighlightedPositions = weakUntilOperator + // .getSecondHighlightedPositions(); + // assertTrue(firstHighlightedPositions.size() == firstArgumentValues + // .size()); + // assertTrue(secondHighlightedPositions.size() == secondArgumentValues + // .size()); + // + // // State 0 + // assertTrue(firstHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // assertTrue(secondHighlightedPositions.get(0).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(0).toArray(new Integer[0]), + // new Integer[] { 0 })); + // + // // State 1 + // assertTrue(firstHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // assertTrue(secondHighlightedPositions.get(1).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(1).toArray(new Integer[0]), + // new Integer[] { 1 })); + // + // // State 2 + // assertTrue(firstHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // assertTrue(secondHighlightedPositions.get(2).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(2).toArray(new Integer[0]), + // new Integer[] { 2 })); + // + // // State 3 + // assertTrue(firstHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // firstHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // assertTrue(secondHighlightedPositions.get(3).size() == 1); + // assertTrue(Arrays.equals( + // secondHighlightedPositions.get(3).toArray(new Integer[0]), + // new Integer[] { 3 })); + // } } diff --git a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java index 5518e5b60f3cba0ce65f9b7b95471c1137e3176c..b7b7e2548bc1d2494bea2ebd6251a825db651e77 100644 --- a/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java +++ b/de.prob.core/test/de/prob/core/domainobjects/ltl/unittests/CounterExampleYesterdayUnitTest.java @@ -1,17 +1,9 @@ package de.prob.core.domainobjects.ltl.unittests; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.List; - import org.junit.Test; -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.core.domainobjects.ltl.CounterExamplePredicate; import de.prob.core.domainobjects.ltl.CounterExampleProposition; import de.prob.core.domainobjects.ltl.CounterExampleUnaryOperator; -import de.prob.core.domainobjects.ltl.CounterExampleValueType; import de.prob.core.domainobjects.ltl.CounterExampleYesterday; /** @@ -27,52 +19,8 @@ public final class CounterExampleYesterdayUnitTest { */ @Test public void testYesterdayOnFinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - PathType.FINITE, argumentValues); - - // create an operator - final CounterExampleUnaryOperator yesterdayOperator = new CounterExampleYesterday( - PathType.FINITE, argument); - - // check result values - final List<CounterExampleValueType> values = yesterdayOperator - .getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = yesterdayOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - assertTrue(highlightedPositions.get(0).size() == 0); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); + final LtlTestDescription d = LtlTestDescription.finite(4); + checkYesterdayFTFT(d); } /* @@ -80,166 +28,10 @@ public final class CounterExampleYesterdayUnitTest { */ @Test public void testYesterdayOnInfinitePath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // Loop entry = 0 - // create an argument - CounterExampleProposition argument = new CounterExamplePredicate( - PathType.INFINITE, 0, argumentValues); - - // create an operator - CounterExampleUnaryOperator yesterdayOperator = new CounterExampleYesterday( - PathType.INFINITE, 0, argument); - - // check result values - List<CounterExampleValueType> values = yesterdayOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - List<List<Integer>> highlightedPositions = yesterdayOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - assertTrue(highlightedPositions.get(0).size() == 0); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - - // Loop entry = 1 - // create an argument - argument = new CounterExamplePredicate(PathType.INFINITE, 1, - argumentValues); - - // create an operator - yesterdayOperator = new CounterExampleYesterday(PathType.INFINITE, 1, - argument); - - // check result values - values = yesterdayOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = yesterdayOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - assertTrue(highlightedPositions.get(0).size() == 0); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - - // Loop entry = 2 - // create an argument - argument = new CounterExamplePredicate(PathType.INFINITE, 2, - argumentValues); - - // create an operator - yesterdayOperator = new CounterExampleYesterday(PathType.INFINITE, 2, - argument); - - // check result values - values = yesterdayOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = yesterdayOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - assertTrue(highlightedPositions.get(0).size() == 0); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); - - // Loop entry = 3 - // create an argument - argument = new CounterExamplePredicate(PathType.INFINITE, 3, - argumentValues); - - // create an operator - yesterdayOperator = new CounterExampleYesterday(PathType.INFINITE, 3, - argument); - - // check result values - values = yesterdayOperator.getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.FALSE); - assertTrue(values.get(2) == CounterExampleValueType.TRUE); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - highlightedPositions = yesterdayOperator.getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - assertTrue(highlightedPositions.get(0).size() == 0); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); + for (int entry = 0; entry < 4; entry++) { + final LtlTestDescription d = LtlTestDescription.loop(4, entry); + checkYesterdayFTFT(d); + } } /* @@ -247,52 +39,28 @@ public final class CounterExampleYesterdayUnitTest { */ @Test public void testYesterdayOnReducedPath() { - // create argument values - final List<CounterExampleValueType> argumentValues = Arrays - .asList(new CounterExampleValueType[] { - CounterExampleValueType.TRUE, - CounterExampleValueType.UNKNOWN, - CounterExampleValueType.FALSE, - CounterExampleValueType.TRUE }); - - // create an argument - final CounterExampleProposition argument = new CounterExamplePredicate( - PathType.REDUCED, argumentValues); - - // create an operator - final CounterExampleUnaryOperator yesterdayOperator = new CounterExampleYesterday( - PathType.REDUCED, argument); - - // check result values - final List<CounterExampleValueType> values = yesterdayOperator - .getValues(); - assertTrue(values.size() == argumentValues.size()); - assertTrue(values.get(0) == CounterExampleValueType.FALSE); - assertTrue(values.get(1) == CounterExampleValueType.TRUE); - assertTrue(values.get(2) == CounterExampleValueType.UNKNOWN); - assertTrue(values.get(3) == CounterExampleValueType.FALSE); - - // check highlighted positions - final List<List<Integer>> highlightedPositions = yesterdayOperator - .getHighlightedPositions(); - assertTrue(highlightedPositions.size() == argumentValues.size()); - - assertTrue(highlightedPositions.get(0).size() == 0); - - assertTrue(highlightedPositions.get(1).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(1).toArray(new Integer[0]), - new Integer[] { 0 })); - - assertTrue(highlightedPositions.get(2).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(2).toArray(new Integer[0]), - new Integer[] { 1 })); - - assertTrue(highlightedPositions.get(3).size() == 1); - assertTrue(Arrays.equals( - highlightedPositions.get(3).toArray(new Integer[0]), - new Integer[] { 2 })); + final LtlTestDescription d = LtlTestDescription.reduced(4); + final CounterExampleProposition arg = d.addArgument("arg", "tuft"); + final CounterExampleUnaryOperator yesterday = new CounterExampleYesterday( + d.getCounterExample(), arg); + d.checkValues("yesterday", yesterday, "ftuf"); + d.expectedHighlight(0, "yestH"); + d.expectedHighlight(1, "yestH", 0); + d.expectedHighlight(2, "yestH", 1); + d.expectedHighlight(3, "yestH", 2); + d.checkHighlights("yesterday", yesterday, "yestH"); + } + private void checkYesterdayFTFT(final LtlTestDescription d) { + final CounterExampleProposition arg = d.addArgument("arg", "ftft"); + final CounterExampleUnaryOperator yesterday = new CounterExampleYesterday( + d.getCounterExample(), arg); + d.checkValues("yesterday", yesterday, "fftf"); + d.expectedHighlight(0, "yestH"); + d.expectedHighlight(1, "yestH", 0); + d.expectedHighlight(2, "yestH", 1); + d.expectedHighlight(3, "yestH", 2); + d.checkHighlights("yesterday", yesterday, "yestH"); } + } diff --git a/de.prob.ui/src/de/prob/ui/ltl/CounterExamplePropositionFigure.java b/de.prob.ui/src/de/prob/ui/ltl/CounterExamplePropositionFigure.java index 3de3e529ea6d8647c02a632f199b029aa0b45106..36ccaa555f85055cd4404c8efe5566025968d23d 100644 --- a/de.prob.ui/src/de/prob/ui/ltl/CounterExamplePropositionFigure.java +++ b/de.prob.ui/src/de/prob/ui/ltl/CounterExamplePropositionFigure.java @@ -32,8 +32,10 @@ import org.eclipse.swt.graphics.Font; import org.eclipse.swt.widgets.Display; import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.Operation; import de.prob.core.domainobjects.ltl.CounterExample; import de.prob.core.domainobjects.ltl.CounterExampleProposition; +import de.prob.core.domainobjects.ltl.CounterExampleState; import de.prob.core.domainobjects.ltl.CounterExampleValueType; public abstract class CounterExamplePropositionFigure extends Figure implements @@ -145,8 +147,10 @@ public abstract class CounterExamplePropositionFigure extends Figure implements protected String getOperationName(final int index) { final CounterExampleFigure parentFigure = (CounterExampleFigure) getParent(); final CounterExample parentModel = parentFigure.getModel(); - final String operationName = parentModel.getStates().get(index) - .getOperation().getName(); + final List<CounterExampleState> states = parentModel.getStates(); + final CounterExampleState state = states.get(index); + final Operation operation = state.getOperation(); + final String operationName = operation.getName(); return operationName; } diff --git a/de.prob.ui/src/de/prob/ui/ltl/CounterExampleTab.java b/de.prob.ui/src/de/prob/ui/ltl/CounterExampleTab.java new file mode 100644 index 0000000000000000000000000000000000000000..f3170291f8de5203287d1e9fc52cafee06d9bd99 --- /dev/null +++ b/de.prob.ui/src/de/prob/ui/ltl/CounterExampleTab.java @@ -0,0 +1,369 @@ +/** + * + */ +package de.prob.ui.ltl; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; + +import org.eclipse.gef.DefaultEditDomain; +import org.eclipse.gef.EditDomain; +import org.eclipse.gef.EditPart; +import org.eclipse.gef.GraphicalViewer; +import org.eclipse.gef.editparts.ScalableRootEditPart; +import org.eclipse.gef.editparts.ZoomManager; +import org.eclipse.gef.print.PrintGraphicalViewerOperation; +import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer; +import org.eclipse.jface.layout.TableColumnLayout; +import org.eclipse.jface.viewers.ArrayContentProvider; +import org.eclipse.jface.viewers.ColumnWeightData; +import org.eclipse.jface.viewers.TableViewer; +import org.eclipse.jface.viewers.TableViewerColumn; +import org.eclipse.jface.viewers.TreeViewer; +import org.eclipse.jface.viewers.TreeViewerColumn; +import org.eclipse.swt.SWT; +import org.eclipse.swt.SWTException; +import org.eclipse.swt.custom.CTabFolder; +import org.eclipse.swt.custom.CTabItem; +import org.eclipse.swt.custom.SashForm; +import org.eclipse.swt.custom.StackLayout; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.printing.PrintDialog; +import org.eclipse.swt.printing.Printer; +import org.eclipse.swt.printing.PrinterData; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Control; +import org.eclipse.swt.widgets.Display; + +import de.prob.core.Animator; +import de.prob.core.command.LtlCheckingCommand.PathType; +import de.prob.core.domainobjects.History; +import de.prob.core.domainobjects.HistoryItem; +import de.prob.core.domainobjects.Operation; +import de.prob.core.domainobjects.State; +import de.prob.core.domainobjects.ltl.CounterExample; +import de.prob.core.domainobjects.ltl.CounterExampleProposition; +import de.prob.core.domainobjects.ltl.CounterExampleState; +import de.prob.logging.Logger; +import de.prob.ui.ltl.CounterExampleViewPart.ViewType; + +/** + * @author plagge + * + */ +public class CounterExampleTab { + private final CounterExample counterExample; + + private final CTabItem tabItem; + private final StackLayout layout; + + // Table view + private final TableViewer tableViewer; + + // Tree view + private final TreeViewer treeViewer; + + // Graphical view + private final ScalableRootEditPart rootEditPart; + private final GraphicalViewer graphicalViewer; + private final Control interactiveView; + + // TODO remove it! + private int currentIndex = -1; + + public CounterExampleTab(final CTabFolder tabFolder, + final CounterExample counterExample) { + this.counterExample = counterExample; + + tabItem = new CTabItem(tabFolder, SWT.CLOSE); + tabItem.setText(counterExample.getPropositionRoot().toString()); + + final Composite sashForm = new SashForm(tabFolder, SWT.HORIZONTAL); + tabItem.setControl(sashForm); + + final Composite composite = new Composite(sashForm, SWT.None); + + layout = new StackLayout(); + composite.setLayout(layout); + + final Composite tableView = new Composite(composite, SWT.None); + tableViewer = createTableViewer(tableView, counterExample); + // createPopupMenu(tableViewer.getTable(), tableViewer); + + final Composite treeView = new Composite(composite, SWT.None); + treeView.setLayout(new FillLayout()); + treeViewer = createTreeViewer(treeView, counterExample); + // createPopupMenu(treeViewer.getTree(), treeViewer); + + rootEditPart = new ScalableRootEditPart(); + graphicalViewer = new ScrollingGraphicalViewer(); + + interactiveView = graphicalViewer.createControl(composite); + interactiveView.setBackground(Display.getDefault().getSystemColor( + SWT.COLOR_WHITE)); + // createPopupMenu(interactiveView, graphicalViewer); + + graphicalViewer.setRootEditPart(rootEditPart); + graphicalViewer.setEditPartFactory(new CounterExampleEditPartFactory()); + graphicalViewer.setContents(counterExample); + + EditDomain editDomain = new DefaultEditDomain(null); + editDomain.addViewer(graphicalViewer); + } + + public CTabItem getTabitem() { + return tabItem; + } + + private TableViewer createTableViewer(Composite parent, + final CounterExample counterExample) { + final CounterExampleTableViewer tableViewer = new CounterExampleTableViewer( + parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); + tableViewer.getTable().setHeaderVisible(true); + tableViewer.getTable().setLinesVisible(true); + + final TableColumnLayout layout = new TableColumnLayout(); + parent.setLayout(layout); + createEventColumn(tableViewer, layout); + + final Collection<CounterExampleProposition> propositions = counterExample + .getPropositionRoot().getChildren(); + + for (CounterExampleProposition proposition : propositions) { + createPropositionColumn(tableViewer, layout, proposition); + } + + tableViewer.getTable().setToolTipText( + "Click to show the state in the history"); + + tableViewer.getTable() + .addMouseListener( + new CounterExampleTableMouseAdapter(tableViewer, + counterExample)); + + tableViewer.setContentProvider(new ArrayContentProvider()); + tableViewer.setInput(counterExample.getStates()); + + return tableViewer; + } + + private void createEventColumn(final TableViewer tableViewer, + final TableColumnLayout layout) { + final TableViewerColumn tableViewerColumn = new TableViewerColumn( + tableViewer, SWT.NONE); + tableViewerColumn.setLabelProvider(new TableColumnEventLabelProvider()); + tableViewerColumn.getColumn().setText("Event"); + tableViewerColumn.getColumn().setAlignment(SWT.CENTER); + layout.setColumnData(tableViewerColumn.getColumn(), + new ColumnWeightData(1)); + } + + private void createPropositionColumn(final TableViewer tableViewer, + final TableColumnLayout layout, + final CounterExampleProposition proposition) { + final TableViewerColumn tableViewerColumn = new TableViewerColumn( + tableViewer, SWT.NONE); + tableViewerColumn.setLabelProvider(new TableColumnValueLabelProvider( + proposition)); + tableViewerColumn.getColumn().setText(proposition.toString()); + tableViewerColumn.getColumn().setAlignment(SWT.CENTER); + layout.setColumnData(tableViewerColumn.getColumn(), + new ColumnWeightData(1)); + } + + private TreeViewer createTreeViewer(Composite parent, + CounterExample counterExample) { + final CounterExampleTreeViewer treeViewer = new CounterExampleTreeViewer( + parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); + + treeViewer.getTree().setHeaderVisible(true); + treeViewer.getTree().setLinesVisible(true); + + TreeViewerColumn propositionColumn = new TreeViewerColumn(treeViewer, + SWT.CENTER); + propositionColumn + .setLabelProvider(new TreeColumnPropositionLabelProvider()); + propositionColumn.getColumn().setAlignment(SWT.CENTER); + propositionColumn.getColumn().setText("Proposition"); + + for (int j = 0; j < counterExample.getStates().size(); j++) { + TreeViewerColumn column = new TreeViewerColumn(treeViewer, + SWT.CENTER); + column.getColumn().setAlignment(SWT.CENTER); + + CounterExampleState state = counterExample.getStates().get(j); + column.setLabelProvider(new TreeColumnValueLabelProvider(state)); + Operation operation = state.getOperation(); + + if (operation != null) + column.getColumn().setText(operation.getName()); + else + column.getColumn().setText("No operation"); + + column.getColumn().pack(); + } + + treeViewer.getTree().setToolTipText( + "Click to show the state in the history"); + + treeViewer.getTree().addMouseListener( + new CounterExampleTreeMouseAdapter(treeViewer, counterExample)); + + // treeViewer.getTree().addMouseMoveListener( + // new CounterExampleTreeMouseMoveAdapter(treeViewer)); + + treeViewer.setContentProvider(new CounterExampleContentProvider()); + treeViewer.setInput(Arrays + .asList(new CounterExampleProposition[] { counterExample + .getPropositionRoot() })); + + treeViewer.expandAll(); + propositionColumn.getColumn().pack(); + + return treeViewer; + } + + public void printCounterExample(final String title) { + final PrintDialog dialog = new PrintDialog(graphicalViewer.getControl() + .getShell(), SWT.NULL); + + try { + final PrinterData printerData = dialog.open(); + if (printerData != null) { + final PrintGraphicalViewerOperation viewerOperation = new PrintGraphicalViewerOperation( + new Printer(printerData), graphicalViewer); + + viewerOperation.run(title); + } + } catch (SWTException e) { + Logger.notifyUser("Failed to print the LTL counter example.", e); + } + } + + public void updateTopControl(final ViewType viewType) { + final Control topControl; + switch (viewType) { + case TABLE: + topControl = tableViewer.getControl(); + break; + case TREE: + topControl = treeViewer.getControl(); + break; + case INTERACTIVE: + topControl = interactiveView; + break; + default: + throw new IllegalStateException( + "Unexpected view type in LTL counter-example view"); + } + + layout.topControl = topControl; + if (layout.topControl != null) { + final Composite parent = layout.topControl.getParent(); + if (parent != null) { + parent.layout(); + } + } + + } + + public CounterExample getCounterExample() { + return counterExample; + } + + public void zoomIn() { + final ZoomManager zoomManager = rootEditPart.getZoomManager(); + if (zoomManager != null) { + if (zoomManager != null && zoomManager.canZoomIn()) { + zoomManager.setZoom(zoomManager.getNextZoomLevel()); + } + } + } + + public void zoomOut() { + final ZoomManager zoomManager = rootEditPart.getZoomManager(); + if (zoomManager != null) { + if (zoomManager != null && zoomManager.canZoomOut()) { + zoomManager.setZoom(zoomManager.getPreviousZoomLevel()); + } + } + } + + protected void stateChanged(final State activeState, + final Operation operation) { + if (activeState.isInitialized()) { + final List<Operation> fullPath = counterExample.getFullPath(); + + final Animator animator = Animator.getAnimator(); + final History history = animator.getHistory(); + + if (isCounterExampleLoadedInHistory(counterExample)) { + final int initPathSize = counterExample.getInitPath().size(); + + currentIndex = history.getCurrentPosition() - initPathSize; + + // HistoryItem item = history.getCurrent(); + + if (counterExample.getPathType() == PathType.INFINITE + && currentIndex == fullPath.size() - initPathSize) { + currentIndex = counterExample.getLoopEntry(); + } + } + + treeViewer.refresh(); + tableViewer.refresh(); + // We know that each element is of type + // EditPart, but AbstractEditPart.getChildren() returns just + // a list + @SuppressWarnings("unchecked") + List<EditPart> children = rootEditPart.getChildren(); + for (EditPart child : children) { + child.refresh(); + } + + currentIndex = -1; + } + } + + private boolean isCounterExampleLoadedInHistory(final CounterExample ce) { + final List<Operation> fullPath = ce.getFullPath(); + + final Animator animator = Animator.getAnimator(); + final History history = animator.getHistory(); + final List<HistoryItem> historyItems = new ArrayList<HistoryItem>( + Arrays.asList(history.getAllItems())); + + final boolean isLoaded; + if (!historyItems.isEmpty()) { + if (historyItems.get(historyItems.size() - 1).getOperation() == null) { + historyItems.remove(historyItems.size() - 1); + } + + if (fullPath.size() == historyItems.size()) { + boolean ceIsEqual = true; + for (int i = 0; i < fullPath.size(); i++) { + final Operation ceOperation = fullPath.get(i); + final Operation histOperation = historyItems.get(i) + .getOperation(); + if (!ceOperation.equals(histOperation)) { + ceIsEqual = false; + break; + } + } + isLoaded = ceIsEqual; + } else { + isLoaded = false; + } + } else { + isLoaded = false; + } + return isLoaded; + } + + public int getCurrentIndex() { + return currentIndex; + } + +} diff --git a/de.prob.ui/src/de/prob/ui/ltl/CounterExampleViewPart.java b/de.prob.ui/src/de/prob/ui/ltl/CounterExampleViewPart.java index 170dc8ee37a0bf7e36f9f2e5a021c79e64f39bd0..f2c3ccd9680fa36bbe722ef66e7fc440a2ed4719 100644 --- a/de.prob.ui/src/de/prob/ui/ltl/CounterExampleViewPart.java +++ b/de.prob.ui/src/de/prob/ui/ltl/CounterExampleViewPart.java @@ -1,41 +1,14 @@ package de.prob.ui.ltl; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; - import org.eclipse.core.commands.Command; import org.eclipse.core.commands.ExecutionException; import org.eclipse.core.commands.ParameterizedCommand; -import org.eclipse.gef.DefaultEditDomain; -import org.eclipse.gef.EditDomain; -import org.eclipse.gef.EditPart; -import org.eclipse.gef.GraphicalViewer; -import org.eclipse.gef.editparts.ScalableRootEditPart; -import org.eclipse.gef.editparts.ZoomManager; -import org.eclipse.gef.print.PrintGraphicalViewerOperation; -import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer; import org.eclipse.jface.action.MenuManager; -import org.eclipse.jface.layout.TableColumnLayout; -import org.eclipse.jface.viewers.ArrayContentProvider; -import org.eclipse.jface.viewers.ColumnWeightData; -import org.eclipse.jface.viewers.TableViewer; -import org.eclipse.jface.viewers.TableViewerColumn; -import org.eclipse.jface.viewers.TreeViewer; -import org.eclipse.jface.viewers.TreeViewerColumn; import org.eclipse.swt.SWT; -import org.eclipse.swt.SWTException; import org.eclipse.swt.custom.CTabFolder; import org.eclipse.swt.custom.CTabFolder2Adapter; import org.eclipse.swt.custom.CTabFolderEvent; import org.eclipse.swt.custom.CTabItem; -import org.eclipse.swt.custom.SashForm; -import org.eclipse.swt.custom.StackLayout; -import org.eclipse.swt.layout.FillLayout; -import org.eclipse.swt.printing.PrintDialog; -import org.eclipse.swt.printing.Printer; -import org.eclipse.swt.printing.PrinterData; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; @@ -46,15 +19,9 @@ import org.eclipse.ui.handlers.HandlerUtil; import org.eclipse.ui.menus.CommandContributionItem; import org.eclipse.ui.services.ISourceProviderService; -import de.prob.core.Animator; -import de.prob.core.command.LtlCheckingCommand.PathType; -import de.prob.core.domainobjects.History; -import de.prob.core.domainobjects.HistoryItem; import de.prob.core.domainobjects.Operation; import de.prob.core.domainobjects.State; import de.prob.core.domainobjects.ltl.CounterExample; -import de.prob.core.domainobjects.ltl.CounterExampleProposition; -import de.prob.core.domainobjects.ltl.CounterExampleState; import de.prob.logging.Logger; import de.prob.ui.StateBasedViewPart; @@ -73,44 +40,6 @@ public final class CounterExampleViewPart extends StateBasedViewPart { INTERACTIVE, TREE, TABLE }; - private static class TabData { - private final CounterExample counterExample; - - private final StackLayout layout; - - // Table view - private final Composite tableView; - private final TableViewer tableViewer; - - // Tree view - private final Composite treeView; - private final TreeViewer treeViewer; - - // Graphical view - private final ScalableRootEditPart editPart; - private final GraphicalViewer graphicalViewer; - private final Control interactiveView; - - public TabData(CounterExample counterExample, StackLayout layout, - Composite tableView, TableViewer tableViewer, - Composite treeView, TreeViewer treeViewer, - ScalableRootEditPart editPart, GraphicalViewer graphicalViewer, - Control interactiveView) { - super(); - this.counterExample = counterExample; - this.layout = layout; - this.tableView = tableView; - this.tableViewer = tableViewer; - this.treeView = treeView; - this.treeViewer = treeViewer; - this.editPart = editPart; - this.graphicalViewer = graphicalViewer; - this.interactiveView = interactiveView; - } - } - - private final List<CounterExample> counterExamples = new ArrayList<CounterExample>(); - private CTabFolder tabFolder; private ViewType viewType = ViewType.INTERACTIVE; private int currentIndex = -1; @@ -151,9 +80,7 @@ public final class CounterExampleViewPart extends StateBasedViewPart { public void addCounterExample(final CounterExample counterExample) { initializeMenuSetting(); - updateCounterExampleLoadedProvider(true); - counterExamples.add(counterExample); final Runnable runnable = new Runnable() { @Override @@ -198,137 +125,48 @@ public final class CounterExampleViewPart extends StateBasedViewPart { } public void zoomInCounterExample() { - final ZoomManager zoomManager = getZoomManager(); - if (zoomManager != null) { - if (zoomManager != null && zoomManager.canZoomIn()) { - zoomManager.setZoom(zoomManager.getNextZoomLevel()); - } + final CounterExampleTab tab = getCurrentTab(); + if (tab != null) { + tab.zoomIn(); } } public void zoomOutCounterExample() { - final ZoomManager zoomManager = getZoomManager(); - if (zoomManager != null) { - if (zoomManager != null && zoomManager.canZoomOut()) { - zoomManager.setZoom(zoomManager.getPreviousZoomLevel()); - } + final CounterExampleTab tab = getCurrentTab(); + if (tab != null) { + tab.zoomOut(); } } - private ZoomManager getZoomManager() { - final TabData data = getCurrentTabData(); - return data == null ? null : data.editPart.getZoomManager(); - } - public void printCounterExample() { - final TabData data = getCurrentTabData(); - if (data != null) { - final GraphicalViewer graphicalViewer = data.graphicalViewer; - final PrintDialog dialog = new PrintDialog(graphicalViewer - .getControl().getShell(), SWT.NULL); - - try { - final PrinterData printerData = dialog.open(); - if (printerData != null) { - final PrintGraphicalViewerOperation viewerOperation = new PrintGraphicalViewerOperation( - new Printer(printerData), graphicalViewer); - - viewerOperation.run(getTitle()); - } - } catch (SWTException e) { - Logger.notifyUser("Failed to print the LTL counter example.", e); - } + final CounterExampleTab tab = getCurrentTab(); + if (tab != null) { + tab.printCounterExample(getTitle()); } } public void setViewType(ViewType viewType) { this.viewType = viewType; for (CTabItem tabItem : tabFolder.getItems()) { - final TabData data = getTabData(tabItem); - updateTopControl(data); + final CounterExampleTab tab = getTab(tabItem); + tab.updateTopControl(viewType); } } public int getCurrentIndex() { - return currentIndex; + final CounterExampleTab tab = getCurrentTab(); + return tab != null ? tab.getCurrentIndex() : -1; } @Override protected void stateChanged(final State activeState, final Operation operation) { - final TabData data = getCurrentTabData(); - if (data != null) { - if (activeState.isInitialized()) { - final CounterExample ce = data.counterExample; - final List<Operation> fullPath = ce.getFullPath(); - - final Animator animator = Animator.getAnimator(); - final History history = animator.getHistory(); - - if (isCounterExampleLoadedInHistory(data.counterExample)) { - final int initPathSize = ce.getInitPath().size(); - - currentIndex = history.getCurrentPosition() - initPathSize; - - // HistoryItem item = history.getCurrent(); - - if (ce.getPathType() == PathType.INFINITE - && currentIndex == fullPath.size() - initPathSize) { - currentIndex = ce.getLoopEntry(); - } - } - - data.treeViewer.refresh(); - data.tableViewer.refresh(); - // We know that each element is of type - // EditPart, but AbstractEditPart.getChildren() returns just - // a list - @SuppressWarnings("unchecked") - List<EditPart> children = data.editPart.getChildren(); - for (EditPart child : children) { - child.refresh(); - } - - currentIndex = -1; - } + final CounterExampleTab tab = getCurrentTab(); + if (tab != null) { + tab.stateChanged(activeState, operation); } } - private boolean isCounterExampleLoadedInHistory(final CounterExample ce) { - final List<Operation> fullPath = ce.getFullPath(); - - final Animator animator = Animator.getAnimator(); - final History history = animator.getHistory(); - final List<HistoryItem> historyItems = new ArrayList<HistoryItem>( - Arrays.asList(history.getAllItems())); - - final boolean isLoaded; - if (!historyItems.isEmpty()) { - if (historyItems.get(historyItems.size() - 1).getOperation() == null) { - historyItems.remove(historyItems.size() - 1); - } - - if (fullPath.size() == historyItems.size()) { - boolean ceIsEqual = true; - for (int i = 0; i < fullPath.size(); i++) { - final Operation ceOperation = fullPath.get(i); - final Operation histOperation = historyItems.get(i) - .getOperation(); - if (!ceOperation.equals(histOperation)) { - ceIsEqual = false; - break; - } - } - isLoaded = ceIsEqual; - } else { - isLoaded = false; - } - } else { - isLoaded = false; - } - return isLoaded; - } - @Override protected void stateReset() { super.stateReset(); @@ -341,6 +179,11 @@ public final class CounterExampleViewPart extends StateBasedViewPart { updateCounterExampleLoadedProvider(false); } + public CounterExample getCurrentCounterExample() { + final CounterExampleTab data = getCurrentTab(); + return data == null ? null : data.getCounterExample(); + } + private void updateCounterExampleLoadedProvider(boolean enabled) { ISourceProviderService service = (ISourceProviderService) getSite() .getService(ISourceProviderService.class); @@ -351,214 +194,27 @@ public final class CounterExampleViewPart extends StateBasedViewPart { } private CTabItem createTabItem(final CounterExample counterExample) { - final CTabItem tabItem = new CTabItem(tabFolder, SWT.CLOSE); - tabItem.setText(counterExample.getPropositionRoot().toString()); - - final Composite sashForm = new SashForm(tabFolder, SWT.HORIZONTAL); - tabItem.setControl(sashForm); - - final Composite composite = new Composite(sashForm, SWT.None); - - final StackLayout layout = new StackLayout(); - composite.setLayout(layout); - - final Composite tableView = new Composite(composite, SWT.None); - TableViewer tableViewer = createTableViewer(tableView, counterExample); - // createPopupMenu(tableViewer.getTable(), tableViewer); - - final Composite treeView = new Composite(composite, SWT.None); - treeView.setLayout(new FillLayout()); - TreeViewer treeViewer = createTreeViewer(treeView, counterExample); - // createPopupMenu(treeViewer.getTree(), treeViewer); - - final ScalableRootEditPart rootEditPart = new ScalableRootEditPart(); - final GraphicalViewer graphicalViewer = new ScrollingGraphicalViewer(); - - final Control interactiveView = graphicalViewer - .createControl(composite); - interactiveView.setBackground(Display.getDefault().getSystemColor( - SWT.COLOR_WHITE)); - // createPopupMenu(interactiveView, graphicalViewer); - - graphicalViewer.setRootEditPart(rootEditPart); - graphicalViewer.setEditPartFactory(new CounterExampleEditPartFactory()); - graphicalViewer.setContents(counterExample); - - EditDomain editDomain = new DefaultEditDomain(null); - editDomain.addViewer(graphicalViewer); - - final TabData tabData = new TabData(counterExample, layout, tableView, - tableViewer, treeView, treeViewer, rootEditPart, - graphicalViewer, interactiveView); - tabItem.setData(DATA_KEY, tabData); - - updateTopControl(tabData); + final CounterExampleTab ceTab = new CounterExampleTab(tabFolder, + counterExample); + final CTabItem tabItem = ceTab.getTabitem(); + tabItem.setData(DATA_KEY, ceTab); + ceTab.updateTopControl(viewType); return tabItem; } - private void updateTopControl(final TabData data) { - final Control topControl; - switch (viewType) { - case TABLE: - topControl = data.tableView; - break; - case TREE: - topControl = data.treeView; - break; - case INTERACTIVE: - topControl = data.interactiveView; - break; - default: - throw new IllegalStateException( - "Unexpected view type in LTL counter-example view"); - } - - final StackLayout layout = data.layout; - layout.topControl = topControl; - if (layout.topControl != null) { - final Composite parent = layout.topControl.getParent(); - if (parent != null) { - parent.layout(); - } - } - - } - - private TableViewer createTableViewer(Composite parent, - final CounterExample counterExample) { - final CounterExampleTableViewer tableViewer = new CounterExampleTableViewer( - parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); - tableViewer.getTable().setHeaderVisible(true); - tableViewer.getTable().setLinesVisible(true); - - final TableColumnLayout layout = new TableColumnLayout(); - parent.setLayout(layout); - createEventColumn(tableViewer, layout); - - final Collection<CounterExampleProposition> propositions = counterExample - .getPropositionRoot().getChildren(); - - for (CounterExampleProposition proposition : propositions) { - createPropositionColumn(tableViewer, layout, proposition); - } - - tableViewer.getTable().setToolTipText( - "Click to show the state in the history"); - - tableViewer.getTable() - .addMouseListener( - new CounterExampleTableMouseAdapter(tableViewer, - counterExample)); - - tableViewer.setContentProvider(new ArrayContentProvider()); - tableViewer.setInput(counterExample.getStates()); - - return tableViewer; - } - - private void createEventColumn(final TableViewer tableViewer, - final TableColumnLayout layout) { - final TableViewerColumn tableViewerColumn = new TableViewerColumn( - tableViewer, SWT.NONE); - tableViewerColumn.setLabelProvider(new TableColumnEventLabelProvider()); - tableViewerColumn.getColumn().setText("Event"); - tableViewerColumn.getColumn().setAlignment(SWT.CENTER); - layout.setColumnData(tableViewerColumn.getColumn(), - new ColumnWeightData(1)); - } - - private void createPropositionColumn(final TableViewer tableViewer, - final TableColumnLayout layout, - final CounterExampleProposition proposition) { - final TableViewerColumn tableViewerColumn = new TableViewerColumn( - tableViewer, SWT.NONE); - tableViewerColumn.setLabelProvider(new TableColumnValueLabelProvider( - proposition)); - tableViewerColumn.getColumn().setText(proposition.toString()); - tableViewerColumn.getColumn().setAlignment(SWT.CENTER); - layout.setColumnData(tableViewerColumn.getColumn(), - new ColumnWeightData(1)); - } - - private TreeViewer createTreeViewer(Composite parent, - CounterExample counterExample) { - final CounterExampleTreeViewer treeViewer = new CounterExampleTreeViewer( - parent, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); - - treeViewer.getTree().setHeaderVisible(true); - treeViewer.getTree().setLinesVisible(true); - - TreeViewerColumn propositionColumn = new TreeViewerColumn(treeViewer, - SWT.CENTER); - propositionColumn - .setLabelProvider(new TreeColumnPropositionLabelProvider()); - propositionColumn.getColumn().setAlignment(SWT.CENTER); - propositionColumn.getColumn().setText("Proposition"); - - for (int j = 0; j < counterExample.getStates().size(); j++) { - TreeViewerColumn column = new TreeViewerColumn(treeViewer, - SWT.CENTER); - column.getColumn().setAlignment(SWT.CENTER); - - CounterExampleState state = counterExample.getStates().get(j); - column.setLabelProvider(new TreeColumnValueLabelProvider(state)); - Operation operation = state.getOperation(); - - if (operation != null) - column.getColumn().setText(operation.getName()); - else - column.getColumn().setText("No operation"); - - column.getColumn().pack(); - } - - treeViewer.getTree().setToolTipText( - "Click to show the state in the history"); - - treeViewer.getTree().addMouseListener( - new CounterExampleTreeMouseAdapter(treeViewer, counterExample)); - - // treeViewer.getTree().addMouseMoveListener( - // new CounterExampleTreeMouseMoveAdapter(treeViewer)); - - treeViewer.setContentProvider(new CounterExampleContentProvider()); - treeViewer.setInput(Arrays - .asList(new CounterExampleProposition[] { counterExample - .getPropositionRoot() })); - - treeViewer.expandAll(); - propositionColumn.getColumn().pack(); - - return treeViewer; - } - - public CounterExample getCurrentCounterExample() { - final TabData data = getCurrentTabData(); - return data == null ? null : data.counterExample; - } - - private TabData getCurrentTabData() { - final TabData data; + private CounterExampleTab getCurrentTab() { + final CounterExampleTab tab; if (tabFolder != null) { final CTabItem selection = tabFolder.getSelection(); - data = getTabData(selection); + tab = getTab(selection); } else { - data = null; + tab = null; } - return data; + return tab; } - private TabData getTabData(final CTabItem item) { - return item == null ? null : (TabData) item.getData(DATA_KEY); + private CounterExampleTab getTab(final CTabItem item) { + return item == null ? null : (CounterExampleTab) item.getData(DATA_KEY); } - - // private void createPopupMenu(Control control, - // ISelectionProvider selectionProvider) { - // MenuManager menuManager = new MenuManager(); - // Menu viewMenu = menuManager.createContextMenu(control); - // control.setMenu(viewMenu); - // getSite().registerContextMenu(menuManager, selectionProvider); - // getSite().setSelectionProvider(selectionProvider); - // } } \ No newline at end of file