method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
ClientProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testGetQualifier() { tested.getQualifier().apply("q1"); verify(definitionUtils, times(1)).getQualifier(eq("q1")); tested.getQualifier().apply("q2"); verify(definitionUtils, times(1)).getQualifier(eq("q2")); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testGetAllProfileInstances() { Iterable<Profile> profiles = tested.getAllProfileInstances(); Iterator<Profile> iterator = profiles.iterator(); assertEquals(profile1, iterator.next()); assertEquals(profile2, iterator.next()); assertFalse(iterator.hasNext()); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testSelectProfileInstances() { Annotation qualifier = mock(Annotation.class); tested.selectProfileInstances(qualifier); verify(profileInstances, times(1)).select(eq(qualifier)); } |
### Question:
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(profileInstances, times(1)).destroyAll(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void start() { getTarget().start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testStart() { tested.start(); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void rollback() { getTarget().rollback(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testRollback() { tested.rollback(); verify(lifecycle, times(1)).rollback(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).start(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void complete() { getTarget().complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testComplete() { tested.complete(); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testOnMouseDown() { tested.onMouseDown(mock(CanvasMouseDownEvent.class)); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); } |
### Question:
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testOnMouseUp() { tested.onMouseUp(mock(CanvasMouseUpEvent.class)); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testSetItems() { final boolean textItemEnabled = true; final String textItemText = "Insert rule above"; doReturn(textItemEnabled).when(textItem).isEnabled(); doReturn(textItemText).when(textItem).getText(); final String headerItemText = "Header"; doReturn(headerItemText).when(headerItem).getText(); view.setItems(Arrays.asList(textItem, dividerItem, headerItem)); verify(itemsContainer).appendChild(textElement); verify(itemsContainer).appendChild(dividerElement); verify(itemsContainer).appendChild(headerElement); verify(textItemView).setEnabled(eq(textItemEnabled)); verify(textItemView).setText(eq(textItemText)); verify(headerItemView).setText(eq(headerItemText)); final ArgumentCaptor<Command> commandCaptor = ArgumentCaptor.forClass(Command.class); verify(textItemView).addClickHandler(commandCaptor.capture()); commandCaptor.getValue().execute(); verify(presenter).onItemSelected(eq(textItem)); reset(presenter); doReturn(false).when(textItem).isEnabled(); commandCaptor.getValue().execute(); verify(presenter, never()).onItemSelected(any(HasListSelectorControl.ListSelectorTextItem.class)); }
@Test public void testSetItemsUnknownImplementation() { view.setItems(singletonList(mock(HasListSelectorControl.ListSelectorItem.class))); verify(itemsContainer, never()).appendChild(any()); } |
### Question:
RequestCommands implements CommandRequestLifecycle { @Override public void rollback() { rollback = true; } RequestCommands(final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> completedCommand,
final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> rollbackCommand); @Override void start(); void push(Command<AbstractCanvasHandler, CanvasViolation> command); @Override void rollback(); @Override void complete(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testRollback() { Consumer<Command<AbstractCanvasHandler, CanvasViolation>> fireComplete = mock(Consumer.class); tested = new RequestCommands.Builder() .onComplete(fireComplete) .onRollback(c -> command = (CompositeCommand<AbstractCanvasHandler, CanvasViolation>) c) .build(); tested.start(); tested.push(c1); tested.push(c2); tested.rollback(); tested.push(c3); tested.complete(); assertNotNull(command); assertTrue(command.getCommands().contains(c1)); assertTrue(command.getCommands().contains(c2)); assertTrue(command.getCommands().contains(c3)); verify(fireComplete, never()).accept(any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PostConstruct public void init() { lifecycle.listen(() -> this); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testInit() { tested.init(); assertEquals(tested, lifecycle.getTarget()); verify(lifecycle, never()).start(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).complete(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void start() { getDelegate().start(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testStart() { tested.start(); verify(commandManager, times(1)).init(eq(session)); verify(commandManager, times(1)).start(); verify(commandManager, never()).rollback(); verify(commandManager, never()).complete(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void complete() { getDelegate().complete(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testComplete() { tested.start(); tested.complete(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).complete(); verify(commandManager, never()).rollback(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void rollback() { getDelegate().rollback(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testRollback() { tested.start(); tested.rollback(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).rollback(); verify(commandManager, never()).complete(); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAllow() { Command<AbstractCanvasHandler, CanvasViolation> command = mock(Command.class); tested.allow(command); verify(commandManager, times(1)).allow(eq(command)); verify(commandManager, never()).execute(any()); verify(commandManager, never()).undo(); verify(commandManager, never()).undo(any(), any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { Command<AbstractCanvasHandler, CanvasViolation> command = mock(Command.class); tested.execute(command); verify(commandManager, times(1)).execute(eq(command)); verify(commandManager, never()).allow(any()); verify(commandManager, never()).undo(); verify(commandManager, never()).undo(any(), any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testUndo() { tested.undo(); verify(commandManager, times(1)).undo(); verify(commandManager, never()).execute(any()); verify(commandManager, never()).allow(any()); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testOnSessionDestroyed() { tested.start(); tested.onSessionDestroyed(new SessionDestroyedEvent(SESSION_ID, "diagram1", "graph1", mock(Metadata.class))); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroy(eq(commandManager)); } |
### Question:
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.start(); tested.destroy(); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroyAll(); } |
### Question:
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { Object obj = mock(Object.class); CommandManager manager = mock(CommandManager.class); CommandResult expectedResult = mock(CommandResult.class); when(commandRegistry.isEmpty()).thenReturn(false); when(commandRegistry.peek()).thenReturn(command1); when(manager.execute(anyObject(), eq(command1))).thenReturn(expectedResult); CommandResult actualResult = tested.execute(obj, manager); assertEquals(expectedResult, actualResult); verify(manager).execute(eq(obj), eq(command1)); }
@Test @SuppressWarnings("unchecked") public void testExecuteOnNull() { Object obj = mock(Object.class); CommandManager manager = mock(CommandManager.class); when(commandRegistry.isEmpty()).thenReturn(true); RedoCommandHandler tested = new RedoCommandHandler(commandRegistry, registerChangedEvent); assertEquals(GraphCommandResultBuilder.SUCCESS, tested.execute(obj, manager)); verify(manager, never()).execute(anyObject(), any(Command.class)); } |
### Question:
RedoCommandHandler { public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }### Answer:
@Test public void testSetSession() { ClientSession session = mock(ClientSession.class); tested.setSession(session); verify(commandRegistry, times(1)).setRegistryChangeListener(any()); } |
### Question:
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testAllow() { tested.allow(COMMAND_SUCCESS1); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).execute(any(), any()); verify(commandManager, never()).undo(any(), any()); verify(commandRegistry, never()).register(any()); verify(commandRegistry, never()).pop(); verify(commandRegistry, never()).peek(); verify(commandRegistry, never()).clear(); } |
### Question:
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testExecute() { tested.execute(COMMAND_SUCCESS1); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).allow(any(), any()); verify(commandManager, never()).undo(any(), any()); verify(commandRegistry, times(1)).register(any()); assertEquals(1, commandRegistry.getHistory().size()); assertEquals(COMMAND_SUCCESS1, commandRegistry.getHistory().get(0)); verify(commandRegistry, never()).pop(); verify(commandRegistry, never()).peek(); verify(commandRegistry, never()).clear(); } |
### Question:
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }### Answer:
@Test public void testUndo() { commandRegistry.register(COMMAND_SUCCESS1); tested.undo(); verify(commandManager, times(1)).undo(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).execute(any(), any()); verify(commandManager, never()).allow(any(), any()); verify(commandRegistry, times(1)).pop(); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluate() { StatefulGraphEvaluationState.StatefulContainmentState containmentState = new StatefulGraphEvaluationState.StatefulContainmentState(); when(state.getContainmentState()).thenReturn(containmentState); Element parent = new NodeImpl<>("parent"); Node child = new NodeImpl<>("child"); final NodeContainmentContext[] containmentContext = new NodeContainmentContext[1]; tested.evaluate(builder -> containmentContext[0] = builder.containment(parent, child)); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(containmentContext[0])); assertEquals(parent, containmentState.getParent(child)); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testClear() { tested.clear(); verify(state, times(1)).clear(); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void addElement(final Element candidate) { updatedElements.add(candidate); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testAddElement() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public List<Element> getUpdatedElements() { return updatedElements; } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testGetUpdatedElements() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("node 1 should be returned from Updated Elements", node1, tested.getUpdatedElements().get(0)); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { @Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testShow() { view.show(Optional.empty()); verify(viewElementCSSClasses).add(OPEN); verify(viewElement).focus(); } |
### Question:
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void resetUpdatedElements() { updatedElements.clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }### Answer:
@Test public void testResetUpdatedElements() { Element parent = new NodeImpl<>("parent"); tested.addElement(parent); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); tested.resetUpdatedElements(); assertEquals("Updated Elements should be empty", 0, tested.getUpdatedElements().size()); } |
### Question:
DiagramClientErrorHandler extends ClientErrorHandler { public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); } @Inject DiagramClientErrorHandler(final ClientTranslationService translationService); void handleError(ClientRuntimeError error, Consumer<String> showError); }### Answer:
@Test public void handleErrorTest() { reset(clientRuntimeError); when(clientRuntimeError.getThrowable()).thenReturn(new DefinitionNotFoundException("Error", DEFINITION_ID)); diagramClientErrorHandler.handleError(clientRuntimeError, message -> Assert.assertEquals(ERROR_MESSAGE, message)); when(clientRuntimeError.getThrowable()).thenReturn(new RuntimeException()); when(clientRuntimeError.toString()).thenReturn("runtime"); diagramClientErrorHandler.handleError(clientRuntimeError, message -> Assert.assertEquals("runtime", message)); } |
### Question:
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); T get(final String definitionSetId, Class<T> preferenceType); T get(final Annotation qualifier, Class<T> preferenceType); }### Answer:
@Test @SuppressWarnings("unchecked") public void testGet() { StunnerPreferences instance = tested.get(DEF_SET_ID, StunnerPreferences.class); verify(preferencesRegistries, times(1)).select(eq(qualifier)); assertEquals(preferences, instance); }
@Test @SuppressWarnings("unchecked") public void testGetTextPreferences() { StunnerTextPreferences instance = tested.get(DEF_SET_ID, StunnerTextPreferences.class); verify(preferencesRegistries, times(1)).select(eq(qualifier)); assertEquals(textPreferences, instance); } |
### Question:
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testLoad() { final ParameterizedCommand<StunnerPreferences> loadCompleteCallback = mock(ParameterizedCommand.class); final ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); final StunnerPreferences pre = mock(StunnerPreferences.class); doAnswer(invocation -> { ((ParameterizedCommand<StunnerPreferences>) invocation.getArguments()[0]).execute(pre); return null; }).when(preferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); tested.load(metadata, loadCompleteCallback, errorCallback); verify(preferencesHolders, times(1)).select(eq(qualifier)); verify(loadCompleteCallback, times(1)).execute(eq(pre)); verify(errorCallback, never()).execute(any(Throwable.class)); verify(preferencesHolder, times(1)).set(eq(pre), eq(StunnerPreferences.class)); verify(preferencesHolder, times(1)).set(eq(textPreferences), eq(StunnerTextPreferences.class)); }
@Test @SuppressWarnings("unchecked") public void testLoadError() { final ParameterizedCommand<StunnerPreferences> loadCompleteCallback = mock(ParameterizedCommand.class); final ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); final Throwable errorInstance = mock(Throwable.class); doAnswer(new Answer() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { ((ParameterizedCommand<Throwable>) invocation.getArguments()[1]).execute(errorInstance); return null; } }).when(preferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); tested.load(metadata, loadCompleteCallback, errorCallback); verify(preferencesHolders, times(1)).select(eq(qualifier)); verify(errorCallback, times(1)).execute(eq(errorInstance)); verify(loadCompleteCallback, never()).execute(any(StunnerPreferences.class)); verify(preferencesHolder, never()).set(any(StunnerPreferences.class), eq(StunnerPreferences.class)); verify(preferencesHolder, never()).set(any(StunnerTextPreferences.class), eq(StunnerTextPreferences.class)); } |
### Question:
StunnerPreferencesRegistryLoader { @PreDestroy public void destroy() { preferencesHolders.destroyAll(); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(preferencesHolders, times(1)).destroyAll(); } |
### Question:
CanvasFileExport { public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToJpg() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(JPG_DATA_URI); tested.exportToJpg(canvasHandler, "file1"); final ArgumentCaptor<ImageDataUriContent> contentArgumentCaptor = ArgumentCaptor.forClass(ImageDataUriContent.class); verify(imageFileExport, times(1)).export(contentArgumentCaptor.capture(), eq("file1.jpg")); verify(pdfFileExport, never()).export(any(PdfDocument.class), anyString()); final ImageDataUriContent imageDataUriContent = contentArgumentCaptor.getValue(); assertEquals(JPG_DATA_URI, imageDataUriContent.getUri()); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToPng() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(PNG_DATA_URI); tested.exportToPng(canvasHandler, "file1"); final ArgumentCaptor<ImageDataUriContent> contentArgumentCaptor = ArgumentCaptor.forClass(ImageDataUriContent.class); verify(imageFileExport, times(1)).export(contentArgumentCaptor.capture(), eq("file1.png")); verify(pdfFileExport, never()).export(any(PdfDocument.class), anyString()); final ImageDataUriContent imageDataUriContent = contentArgumentCaptor.getValue(); assertEquals(PNG_DATA_URI, imageDataUriContent.getUri()); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); }
@Test public void testExportToPNG() { final String expectedImage = "image"; doNothing().when(tested).clearSelection(any()); when(canvasExport.toImageData(any(), any())).thenReturn(expectedImage); final String actualImage = tested.exportToPng(canvasHandler); verify(tested).clearSelection(canvasHandler); assertEquals(expectedImage, actualImage); } |
### Question:
CanvasFileExport { public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToPdf() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(JPG_DATA_URI); verify(imageFileExport, never()).export(any(ImageDataUriContent.class), anyString()); tested.exportToPdf(canvasHandler, "file1"); verify(pdfFileExport, times(1)).export(any(PdfDocument.class), eq("file1.pdf")); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { @Override public void hide() { getElement().getClassList().remove(OPEN); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testHide() { view.hide(); verify(viewElementCSSClasses).remove(OPEN); } |
### Question:
CanvasFileExport { public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }### Answer:
@Test public void testExportToSVG() { when(canvasExport.toContext2D(eq(canvasHandler), any(CanvasExportSettings.class))).thenReturn(context2D); tested.exportToSvg(canvasHandler, "file1"); verify(svgFileExport, times(1)).export(context2D, "file1.svg"); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
CanvasHighlight { public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }### Answer:
@Test public void testUnhighLight() { tested.highLight(node1); tested.invalid(node2); tested.unhighLight(); verify(shape1, times(1)).applyState(eq(ShapeState.HIGHLIGHT)); verify(shape1, times(1)).applyState(eq(ShapeState.NONE)); verify(shape2, times(1)).applyState(eq(ShapeState.INVALID)); verify(shape2, times(1)).applyState(eq(ShapeState.NONE)); verify(canvasView, atLeastOnce()).setCursor(eq(AbstractCanvas.Cursors.MOVE)); } |
### Question:
CanvasHighlight { public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }### Answer:
@Test public void testDestroy() { tested.highLight(node1); tested.invalid(node2); tested.destroy(); verify(shape1, times(1)).applyState(eq(ShapeState.HIGHLIGHT)); verify(shape1, times(0)).applyState(eq(ShapeState.NONE)); verify(shape2, times(1)).applyState(eq(ShapeState.INVALID)); verify(shape2, times(0)).applyState(eq(ShapeState.NONE)); verify(canvasView, atLeastOnce()).setCursor(eq(AbstractCanvas.Cursors.DEFAULT)); } |
### Question:
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }### Answer:
@Test public void isCanvasRootTrueTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("canvas_root"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, parentCanvasRoot); assertTrue(isCanvasRoot); }
@Test public void isCanvasRootFalseTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("test"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, parentNotCanvasRoot); assertFalse(isCanvasRoot); }
@Test public void isCanvasRootWithUuidTrueTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("canvas_root"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, "canvas_root"); assertTrue(isCanvasRoot); }
@Test public void isCanvasRootWithUuidFalseTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("test"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, "canvas_root"); assertFalse(isCanvasRoot); } |
### Question:
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }### Answer:
@Test public void testGetElementNullCanvasHandlerAndNullUUID() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); assertNull(CanvasLayoutUtils.getElement(null, null)); }
@Test public void testGetElementNullCanvasHandler() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); assertNull(CanvasLayoutUtils.getElement(null, NODE_UUID)); }
@Test public void testGetElementNullUUID() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); assertNull(CanvasLayoutUtils.getElement(abstractCanvasHandler, null)); }
@Test public void testGetElementWithNullIndex() { assertNull(CanvasLayoutUtils.getElement(abstractCanvasHandler, NODE_UUID)); }
@Test public void testGetElement() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); when(graphIndex.get(NODE_UUID)).thenReturn(nodeRoot); assertEquals(nodeRoot, CanvasLayoutUtils.getElement(abstractCanvasHandler, NODE_UUID)); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testRegisterOnCloseHandler() { final EventListener<Event> onKeyDown = (e) -> {}; doReturn(onKeyDown).when(view).onKeyDown(); view.registerOnCloseHandler(); verify(viewElement).addEventListener(KEYDOWN, onKeyDown, false); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void addChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAddChildShape() { tested.addChild(parentShape, childShape); verify(canvasView, times(1)).addChild(eq(parentShapeView), eq(childShapeView)); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void deleteChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDeleteChildShape() { tested.deleteChild(parentShape, childShape); verify(canvasView, times(1)).deleteChild(eq(parentShapeView), eq(childShapeView)); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas dock(final Shape parent, final Shape child) { getView().dock(parent.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDock() { tested.dock(parentShape, childShape); verify(canvasView, times(1)).dock(eq(parentShapeView), eq(childShapeView)); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testUndock() { tested.undock(parentShape, childShape); verify(canvasView, times(1)).undock(eq(parentShapeView), eq(childShapeView)); }
@Test @SuppressWarnings("unchecked") public void testUndockToLayer() { tested.undock(parentShape, childShape); verify(canvasView, times(1)).undock(eq(parentShapeView), eq(childShapeView)); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas addShape(final Shape shape) { shapes.computeIfAbsent(shape.getUUID(), (v) -> { addShapeIntoView(shape); fireCanvasShapeAdded(shape); canvasShapeAddedEvent.fire(new CanvasShapeAddedEvent(this, shape)); return shape; }); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testAddShape() { tested.addShape(parentShape); verify(canvasView, times(1)).add(eq(parentShapeView)); verify(parentShapeView, never()).setUUID(anyString()); assertEquals(1, tested.getShapes().size()); } |
### Question:
ListSelectorViewImpl implements ListSelectorView { void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }### Answer:
@Test public void testReturnFocusToPanel() { view.setOnClosedByKeyboardCallback(canBeClosedByKeyboardConsumer); view.returnFocusToPanel(); verify(canBeClosedByKeyboardConsumer).accept(view); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas deleteShape(final Shape shape) { deleteShapeFromView(shape); fireCanvasShapeRemoved(shape); shapes.remove(shape.getUUID()); canvasShapeRemovedEvent.fire(new CanvasShapeRemovedEvent(this, shape)); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDeleteShape() { tested.shapes.put(parentShape.getUUID(), parentShape); tested.deleteShape(parentShape); verify(canvasView, times(1)).delete(eq(parentShapeView)); assertTrue(tested.getShapes().isEmpty()); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { public AbstractCanvas clear() { return clear(true); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testClear() { tested.shapes.put(parentShape.getUUID(), parentShape); tested.shapes.put(childShape.getUUID(), childShape); tested.clear(); verify(canvasView, times(1)).delete(eq(parentShapeView)); verify(canvasView, times(1)).delete(eq(childShapeView)); assertTrue(tested.getShapes().isEmpty()); verify(canvasView, times(1)).clear(); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public void destroy() { clear(false); listeners.clear(); getView().destroy(); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testDestroy() { tested.shapes.put(parentShape.getUUID(), parentShape); tested.shapes.put(childShape.getUUID(), childShape); tested.destroy(); verify(canvasView, times(1)).delete(eq(parentShapeView)); verify(canvasView, times(1)).delete(eq(childShapeView)); assertTrue(tested.getShapes().isEmpty()); verify(canvasView, times(1)).destroy(); } |
### Question:
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected void clearShapes() { if (!shapes.isEmpty()) { shapes.values().stream().collect(Collectors.toList()).forEach(this::deleteShape); shapes.clear(); } } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testClearShapes() throws Exception { tested.shapes.put(parentShape.getUUID(), parentShape); tested.shapes.put(childShape.getUUID(), childShape); tested.clearShapes(); verify(canvasView, times(1)).delete(eq(parentShapeView)); verify(canvasView, times(1)).delete(eq(childShapeView)); assertTrue(tested.getShapes().isEmpty()); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testRegisterElement() { tested.init(canvasHandler); assertFalse(isRegistered(element)); tested.register(element); assertTrue(isRegistered(element)); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> select(final String uuid) { return select(Collections.singletonList(uuid)); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testSelect() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); assertEquals(1, tested.getSelectedItems().size()); assertEquals(ELEMENT_UUID, tested.getSelectedItems().iterator().next()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, never()).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); verify(canvas, times(1)).focus(); final ArgumentCaptor<CanvasSelectionEvent> elementSelectedEventArgumentCaptor = ArgumentCaptor.forClass(CanvasSelectionEvent.class); verify(elementSelectedEvent, times(1)).fire(elementSelectedEventArgumentCaptor.capture()); final CanvasSelectionEvent event = elementSelectedEventArgumentCaptor.getValue(); assertEquals(1, event.getIdentifiers().size()); assertEquals(ELEMENT_UUID, event.getIdentifiers().iterator().next()); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testDeselect() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.deselect(element.getUUID()); assertTrue(tested.getSelectedItems().isEmpty()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, times(1)).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> clearSelection() { return clearSelection(true); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testClearSelection() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.clearSelection(); assertTrue(tested.getSelectedItems().isEmpty()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, times(1)).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); verify(clearSelectionEvent, times(1)).fire(any(CanvasClearSelectionEvent.class)); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testGetSelectedItemDefinitionWithNoItemsSelected() { tested.init(canvasHandler); when(index.get(ROOT_UUID)).thenReturn(rootElement); final Optional<Object> selectedItemDefinition = tested.getSelectedItemDefinition(); assertTrue(selectedItemDefinition.isPresent()); assertEquals(rootElement, selectedItemDefinition.get()); }
@Test public void testGetSelectedItemDefinitionWithNoItemsSelectedAndNoDiagram() { tested.init(canvasHandler); when(canvasHandler.getDiagram()).thenReturn(null); final Optional<Object> selectedItemDefinition = tested.getSelectedItemDefinition(); assertFalse(selectedItemDefinition.isPresent()); }
@Test public void testDestroy() { tested.init(canvasHandler); tested.destroy(); assertFalse(tested.getSelectedItemDefinition().isPresent()); verify(canvas).removeHandler(any(MouseClickHandler.class)); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public HTMLElement getElement() { return view.getElement(); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test public void testGetElement() { final HTMLElement element = mock(HTMLElement.class); when(popover.getElement()).thenReturn(element); final HTMLElement actual = popover.getElement(); assertEquals(element, actual); } |
### Question:
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void clear() { clearSelection(true); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }### Answer:
@Test public void testClear() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.clear(); assertTrue(tested.getSelectedItems().isEmpty()); verify(clearSelectionEvent, times(1)).fire(canvasClearSelectionEventCaptor.capture()); assertEquals(canvasHandler, canvasClearSelectionEventCaptor.getValue().getCanvasHandler()); } |
### Question:
ClipboardControlCleaner { public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } } @Inject ClipboardControlCleaner(final ManagedInstance<ClipboardControl> clipboardControls, final ActivityBeansCache activityBeansCache); void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event); }### Answer:
@Test public void onPlaceGainFocusEvent() { clipboardControlCleaner.onPlaceGainFocusEvent(placeLostFocusEvent); verify(clipboardControl, times(1)).clear(); } |
### Question:
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }### Answer:
@Test public void testRemove() { localClipboardControl.set(graphInstance.startNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.remove(graphInstance.startNode); assertFalse(localClipboardControl.hasElements()); } |
### Question:
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }### Answer:
@Test public void testClear() { localClipboardControl.set(graphInstance.startNode, graphInstance.intermNode, graphInstance.endNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.clear(); assertFalse(localClipboardControl.hasElements()); } |
### Question:
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public String getParent(String uuid) { return elementsParent.get(uuid); } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }### Answer:
@Test public void testGetParent() { localClipboardControl.set(graphInstance.startNode); String parentUUID = localClipboardControl.getParent(graphInstance.startNode.getUUID()); assertEquals(parentUUID, graphInstance.parentNode.getUUID()); } |
### Question:
CanvasInlineTextEditorControl extends AbstractCanvasInlineTextEditorControl { @PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; } @Inject CanvasInlineTextEditorControl(final FloatingView<IsWidget> floatingView,
final @InlineTextEditorBox TextEditorBox<AbstractCanvasHandler, Element> textEditorBox); }### Answer:
@Test public void testInitParameters() { CanvasInlineTextEditorControl tested = mock(CanvasInlineTextEditorControl.class); doCallRealMethod().when(tested).initParameters(); tested.initParameters(); assertTrue(tested.isMultiline); assertEquals(2d, tested.borderOffsetX, 0.001); assertEquals(2d, tested.borderOffsetY, 0.001); assertEquals(2d, tested.underBoxOffset, 0.001); assertEquals(-2d, tested.topBorderOffset, 0.001); assertEquals(4d, tested.fontSizeCorrection, 0.001); assertEquals(190d, tested.maxInnerLeftBoxWidth, 0.001); assertEquals(190d, tested.maxInnerLeftBoxHeight, 0.001); assertEquals(13d, tested.scrollBarOffset, 0.001); assertEquals(0d, tested.paletteOffsetX, 0.001); assertEquals(190d, tested.maxInnerTopBoxWidth, 0.001); assertEquals(190d, tested.maxInnerTopBoxHeight, 0.001); assertEquals(-1.1d, tested.innerBoxOffsetY, 0.001); } |
### Question:
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }### Answer:
@Test public void testBind() { control.bind(session); verify(keyboardControl, times(2)) .addKeyShortcutCallback(any(KeyboardControl.KeyShortcutCallback.class)); } |
### Question:
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }### Answer:
@Test public void testRegisterTextEnter() { control.init(canvasHandler); when(testShapeView.supports(ViewEventType.TEXT_ENTER)).thenReturn(true); control.register(element); assertTrue(control.isRegistered(element)); verify(testShapeView).addHandler(eq(ViewEventType.TEXT_ENTER), textEnterHandlerCaptor.capture()); final TextEnterHandler textEnterHandler = textEnterHandlerCaptor.getValue(); textEnterHandler.handle(new TextEnterEvent(0, 1, SHAPE_X, SHAPE_Y)); verify(abstractCanvasView).setCursor(eq(AbstractCanvas.Cursors.TEXT)); }
@Test public void testRegisterTextExit() { control.init(canvasHandler); when(testShapeView.supports(ViewEventType.TEXT_EXIT)).thenReturn(true); control.register(element); assertTrue(control.isRegistered(element)); verify(testShapeView).addHandler(eq(ViewEventType.TEXT_EXIT), textExitHandlerCaptor.capture()); final TextExitHandler textExitHandler = textExitHandlerCaptor.getValue(); textExitHandler.handle(new TextExitEvent(0, 1, SHAPE_X, SHAPE_Y)); verify(abstractCanvasView).setCursor(eq(AbstractCanvas.Cursors.DEFAULT)); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSetOnClosedByKeyboardCallbackNullControl() { popover.setOnClosedByKeyboardCallback(callback); verify(view, never()).setOnClosedByKeyboardCallback(any(Consumer.class)); } |
### Question:
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }### Answer:
@Test public void testSetCommandManagerProvider() { control.setCommandManagerProvider(commandManagerProvider); verify(textEditorBox).setCommandManagerProvider(eq(commandManagerProvider)); } |
### Question:
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }### Answer:
@Test public void testAllowOnlyVisualChanges() { final Element element = mock(Element.class); final Definition definition = mock(Definition.class); final DynamicReadOnly dynamicReadOnly = mock(DynamicReadOnly.class); when(element.getContent()).thenReturn(definition); when(definition.getDefinition()).thenReturn(dynamicReadOnly); boolean actual = control.allowOnlyVisualChanges(element); assertFalse(actual); when(dynamicReadOnly.isAllowOnlyVisualChange()).thenReturn(true); actual = control.allowOnlyVisualChanges(element); assertTrue(actual); }
@Test public void testAllowOnlyVisualChangesDefaultValue() { final Element element = mock(Element.class); final boolean actual = control.allowOnlyVisualChanges(element); assertFalse(actual); } |
### Question:
DefaultToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }### Answer:
@Test public void testGetTheRightFactories() { final List<ActionsToolboxFactory> factories = this.tested.getFactories(); assertEquals(3, factories.size()); assertTrue(factories.contains(flowActionsToolboxFactoryInstance)); assertTrue(factories.contains(morphActionsToolboxFactoryInstance)); assertTrue(factories.contains(commonActionsToolboxFactoryInstance)); } |
### Question:
DefaultToolboxControl extends AbstractToolboxControl { @PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(flowActionsToolboxFactory, times(1)).destroyAll(); verify(morphActionsToolboxFactory, times(1)).destroyAll(); verify(commonActionsToolboxFactory, times(1)).destroyAll(); } |
### Question:
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }### Answer:
@Test public void testInitnable() { tested.init(canvasHandler); assertEquals(canvasHandler, tested.getCanvasHandler()); } |
### Question:
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }### Answer:
@Test public void testRegisterElement() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); verify(shapeEventHandler, times(1)).supports(eq(ViewEventType.MOUSE_CLICK)); verify(shapeEventHandler, times(1)).addHandler(eq(ViewEventType.MOUSE_CLICK), any(MouseClickHandler.class)); assertTrue(tested.isRegistered(element)); }
@Test public void testNotSupportedElement() { tested.init(canvasHandler); final Edge edge = mock(Edge.class); tested.register(edge); assertFalse(tested.isRegistered(edge)); verify(shapeEventHandler, never()).supports(any(ViewEventType.class)); verify(shapeEventHandler, never()).addHandler(any(ViewEventType.class), any(MouseClickHandler.class)); }
@Test @SuppressWarnings("unchecked") public void testDeregisterElement() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(shapeEventHandler, times(1)).removeHandler(any(ViewHandler.class)); assertFalse(tested.isRegistered(element)); } |
### Question:
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }### Answer:
@Test public void testShow() { tested.init(canvasHandler); tested.register(element); assertTrue(tested.isRegistered(element)); tested.show(element); verify(toolbox, times(1)).show(); verify(toolbox, never()).hide(); verify(toolbox, never()).destroy(); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testShowNullControl() { popover.show(); verify(view, never()).show(any(Optional.class)); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test public void checkPriorityEnsuresCatchAllOperation() { assertEquals(TextPropertyProviderFactory.CATCH_ALL_PRIORITY, provider.getPriority()); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return true; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test @SuppressWarnings("unchecked") public void checkSupportsAllElements() { assertTrue(provider.supports(element)); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test public void checkReadGetsNameFromPropertyMetaData() { provider.getText(element); verify(definitionUtils).getName(eq(definition)); } |
### Question:
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }### Answer:
@Test public void checkWriteUsesCommandToUpdateNamePropertyMetaData() { provider.setText(canvasHandler, commandManager, element, "text"); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq("name"), eq("text")); verify(commandManager).execute(eq(canvasHandler), eq(command)); } |
### Question:
KeysMatcher { public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; } static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKeys); static boolean isKeyMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKey); }### Answer:
@Test public void checkMatch() { final boolean match = KeysMatcher.doKeysMatch(keysActual.keys, keysExpected.keys); assertEquals(matches, match); } |
### Question:
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }### Answer:
@Test public void testBind() { assertThat(canvasShortcutsControl.editorSession).isNull(); final EditorSession session = mock(EditorSession.class); final KeyboardControl keyboardControl = mock(KeyboardControl.class); doReturn(keyboardControl).when(session).getKeyboardControl(); canvasShortcutsControl.bind(session); assertThat(canvasShortcutsControl.editorSession).isEqualTo(session); verify(keyboardControl).addKeyShortcutCallback(eq(canvasShortcutsControl)); } |
### Question:
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }### Answer:
@Test public void testOnKeyShortcutNothingSelected() { mockSelectedElements(); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.E, mock(Element.class)); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
@Test public void testOnKeyShortcutWrongPressedKey() { final Element selectedElement = mockSelectedElements("element").get(0); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.T, selectedElement); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
@Test public void testOnKeyShortcutWrongElement() { mockSelectedElements("element"); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.E, mock(Element.class)); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
@Test public void testOnKeyShortcutSelectedElements() { mockSelectedElements("element-1", "element-2"); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.E, mock(Element.class)); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); } |
### Question:
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }### Answer:
@Test public void testHideNullControl() { popover.hide(); verify(view, never()).hide(); } |
### Question:
AbstractAppendNodeShortcut implements KeyboardShortcut<AbstractCanvasHandler> { @Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } } AbstractAppendNodeShortcut(final ToolboxDomainLookups toolboxDomainLookups,
final DefinitionsCacheRegistry definitionsCacheRegistry,
final GeneralCreateNodeAction generalCreateNodeAction); @Override void executeAction(final AbstractCanvasHandler canvasHandler,
final String selectedNodeId); abstract boolean canAppendNodeOfDefinition(final Object definition); }### Answer:
@Test public void testAppend() { final Object targetNodeDefinition = mock(Object.class); testedShortcut = new AbstractAppendNodeShortcutMock(targetNodeDefinition); selectedNodeId = "selected"; targetDefinitionNodeId = "target"; connectorDefinitionId = "connector"; definitionSetId = "definition"; when(canvasHandler.getGraphIndex()).thenReturn(graphIndex); when(canvasHandler.getDiagram()).thenReturn(diagram); when(diagram.getGraph()).thenReturn(graph); when(diagram.getMetadata()).thenReturn(metadata); when(metadata.getDefinitionSetId()).thenReturn(definitionSetId); final Element selectedElement = mock(Element.class); when(graphIndex.get(selectedNodeId)).thenReturn(selectedElement); final Node selectedNode = mock(Node.class); when(selectedElement.asNode()).thenReturn(selectedNode); when(toolboxDomainLookups.get(definitionSetId)).thenReturn(commonDomainLookups); final Set<String> connectorDefinitionIds = Collections.singleton(connectorDefinitionId); when(commonDomainLookups.lookupTargetConnectors(selectedNode)).thenReturn(connectorDefinitionIds); final Set<String> targetNodesDefinitionIds = Collections.singleton(targetDefinitionNodeId); when(commonDomainLookups.lookupTargetNodes(graph, selectedNode, connectorDefinitionId)).thenReturn(targetNodesDefinitionIds); when(definitionsCacheRegistry.getDefinitionById(targetDefinitionNodeId)).thenReturn(targetNodeDefinition); testedShortcut.executeAction(canvasHandler, selectedNodeId); verify(generalCreateNodeAction).executeAction(canvasHandler, selectedNodeId, targetDefinitionNodeId, connectorDefinitionId); reset(definitionsCacheRegistry); reset(generalCreateNodeAction); when(definitionsCacheRegistry.getDefinitionById(targetDefinitionNodeId)).thenReturn(new Object()); testedShortcut.executeAction(canvasHandler, selectedNodeId); verify(generalCreateNodeAction, never()).executeAction(any(), any(), any(), any()); } |
### Question:
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } @Inject KeyboardControlImpl(final SessionManager clientSessionManager,
final KeyEventHandler keyEventHandler); @Override KeyboardControl<AbstractCanvas, ClientSession> addKeyShortcutCallback(final KeyShortcutCallback shortcutCallback); void setKeyEventHandlerEnabled(final boolean enabled); @Override void bind(final ClientSession session); }### Answer:
@Test public void testSetKeyEventHandlerEnabled() { tested.setKeyEventHandlerEnabled(true); verify(keyEventHandler, times(1)).setEnabled(eq(true)); } |
### Question:
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } @Override KeyEventHandler addKeyShortcutCallback(final KeyboardControl.KeyShortcutCallback shortcutCallback); @Override KeyEventHandler setTimerDelay(final int millis); @Override @PreDestroy void clear(); @Override void setEnabled(final boolean enabled); void onKeyUpEvent(final @Observes KeyUpEvent event); }### Answer:
@Test public void testOnKeyUp() { tested.onKeyUpEvent(new KeyUpEvent(KeyboardEvent.Key.ALT)); verify(shortcutCallback, times(1)).onKeyUp(eq(KeyboardEvent.Key.ALT)); } |
### Question:
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }### Answer:
@Test public void testAllow() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 0); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 1); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 3); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndex() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.allow(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCP() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.allow(canvasHandler); } |
### Question:
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndexDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.execute(canvasHandler); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCPDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.execute(canvasHandler); }
@Test public void execute() { checkExecution(true); } |
### Question:
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge<? extends View<?>, Node> getEdge(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(edgeShape, times(1)).applyConnections(eq(edge), eq(sourceShapeView), eq(targetShapeView), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
@Test @SuppressWarnings("unchecked") public void testExecuteAndUpdateMagnetLocations() { final MagnetConnection sourceConnection = new MagnetConnection.Builder() .magnet(0) .build(); final MagnetConnection targetConnection = new MagnetConnection.Builder() .magnet(0) .build(); when(edgeContent.getSourceConnection()).thenReturn(Optional.of(sourceConnection)); when(edgeContent.getTargetConnection()).thenReturn(Optional.of(targetConnection)); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(edgeShape, times(1)).applyConnections(eq(edge), eq(sourceShapeView), eq(targetShapeView), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); assertEquals(5d, sourceConnection.getLocation().getX(), 0d); assertEquals(5d, sourceConnection.getLocation().getY(), 0d); assertEquals(10d, targetConnection.getLocation().getX(), 0d); assertEquals(10d, targetConnection.getLocation().getY(), 0d); } |
### Question:
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }### Answer:
@Test public void testCreateOptions() { final PopoverOptions options = mock(PopoverOptions.class); doReturn(options).when(view).createPopoverOptionsInstance(); view.createOptions(); verify(options).setAnimation(false); verify(options).setHtml(true); verify(options).setPlacement(AbstractPopoverViewImpl.PLACEMENT); } |
### Question:
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }### Answer:
@Test public void testNewGraphCommand() { final Command<GraphCommandExecutionContext, RuleViolation> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newGraphCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyValueCommand.class); } |
### Question:
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }### Answer:
@Test public void testNewCanvasCommandExecute() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.execute(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); }
@Test public void testNewCanvasCommandUndo() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.undo(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); } |
### Question:
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } AddCanvasConnectorCommand(final Edge candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); String getShapeSetId(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(candidateShape, times(1)).applyConnections(eq(candidate), eq(sourceShapeView), any(ShapeView.class), any(MutationContext.class)); } |
### Question:
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).addChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, times(0)).dock(any(Node.class), any(Node.class)); verify(connectorShapeView1, times(1)).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, times(1)).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); }
@Test @SuppressWarnings("unchecked") public void testSkipExecutionAsDockIsPresent() { final Edge dockEdge = mock(Edge.class); when(dockEdge.getContent()).thenReturn(new Dock()); graph1Instance.intermNode.getInEdges().add(dockEdge); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, never()).addChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, never()).dock(any(Node.class), any(Node.class)); verify(connectorShapeView1, never()).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, never()).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); } |
### Question:
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }### Answer:
@Test public void testGetGraphCommand() { final org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(candidate, graphCommand.getEdge()); } |
### Question:
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }### Answer:
@Test public void testGetCanvasCommand() { final DeleteCanvasConnectorCommand canvasCommand = (DeleteCanvasConnectorCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); assertEquals(candidate, canvasCommand.getCandidate()); } |
### Question:
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } UpdateCanvasElementPropertyCommand(final Element element); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementProperties(eq(candidate), any(MutationContext.class)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.