src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
SessionEventObserver { void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
@Test public void testOnSessionDiagramSavedEvent() { observer.onSessionDiagramSavedEvent(new SessionDiagramSavedEvent(session)); allSessionDiagramSavedHandlers.forEach(handler -> verify(handler).accepts(diagram)); acceptsDiagramSessionDiagramSavedHandlers.forEach(handler -> verify(handler).onSessionDiagramSaved(session)); dontAcceptsDiagramSessionDiagramSavedHandlers.forEach(handler -> verify(handler, never()).onSessionDiagramSaved(session)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testCreate() { final String name = "d1"; final String defSetId = "id1"; final ServiceCallback<Path> callback = mock(ServiceCallback.class); tested.create(path, name, defSetId, callback); verify(diagramService, times(1)).create(eq(path), eq(name), eq(defSetId)); verify(callback, times(1)).onSuccess(any(Path.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testAdd() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.add(diagram, callback); verify(diagramService, times(1)).saveOrUpdate(eq(diagram)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testSaveOrUpdate() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.saveOrUpdate(diagram, callback); verify(diagramService, times(1)).saveOrUpdate(eq(diagram)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
@Test @SuppressWarnings("unchecked") public void testSaveSessionDiagramSavedEventFiredWhenSaveWasSuccessful() { when(sessionManager.getCurrentSession()).thenReturn(session); ServiceCallback serviceCallback = mock(ServiceCallback.class); when(diagramService.saveOrUpdate(any())).thenReturn(metadata); tested.saveOrUpdate(diagram, serviceCallback); verify(sessionDiagramSavedEvent).fire(new SessionDiagramSavedEvent(session)); }
@Test @SuppressWarnings("unchecked") public void testSaveSessionDiagramSavedEventNotFiredWhenSaveWasUnSuccessful() { TestUtils.prepareServiceCallerError(diagramService, diagramServiceCaller, new Throwable("some error")); when(sessionManager.getCurrentSession()).thenReturn(session); ServiceCallback serviceCallback = mock(ServiceCallback.class); when(diagramService.saveOrUpdate(any())).thenReturn(metadata); tested.saveOrUpdate(diagram, serviceCallback); verify(sessionDiagramSavedEvent, never()).fire(any(SessionDiagramSavedEvent.class)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test public void testSaveOrUpdateSvg() { final ServiceCallback<Path> callback = mock(ServiceCallback.class); tested.saveOrUpdateSvg(path, RAW_DIAGRAM, callback); verify(diagramService).saveOrUpdateSvg(path, RAW_DIAGRAM); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testGetByPath() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.getByPath(path, callback); verify(diagramService, times(1)).getDiagramByPath(eq(path)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testLookup() { final DiagramLookupRequest request = mock(DiagramLookupRequest.class); final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback = mock(ServiceCallback.class); tested.lookup(request, callback); verify(diagramLookupService, times(1)).lookup(eq(request)); verify(callback, times(1)).onSuccess(any(LookupManager.LookupResponse.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testUpdateClientMetadata() { final String ssid = "shapeSet1"; final ShapeSet shapeSet = mock(ShapeSet.class); final ServiceCallback<D> callback = mock(ServiceCallback.class); when(shapeSet.getId()).thenReturn(ssid); when(shapeManager.getDefaultShapeSet(anyString())).thenReturn(shapeSet); when(metadata.getShapeSetId()).thenReturn(null); when(diagramService.getDiagramByPath(eq(path))).thenReturn(diagram); tested.add(diagram, callback); tested.saveOrUpdate(diagram, callback); tested.getByPath(path, callback); verify(metadata, times(3)).setShapeSetId(eq(ssid)); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testGetRawContent() { final ServiceCallback<String> callback = mock(ServiceCallback.class); tested.getRawContent(diagram, callback); verify(diagramService, times(1)).getRawContent(eq(diagram)); verify(callback, times(1)).onSuccess(any(String.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
ClientRuleManager implements RuleManager { @PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testRegisterHandlers() { tested.init(); verify(registry, times(1)).register(eq(handler)); }
|
ClientRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testGetRegistry() { assertEquals(registry, tested.registry()); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }
|
@Test public void testOnItemSelected() { listSelector.bind(bound, 0, 0); listSelector.onItemSelected(listSelectorItem2); verify(bound).onItemSelected(eq(listSelectorItem2)); }
|
ClientRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testEvaluate() { RuleSet ruleSet = mock(RuleSet.class); RuleEvaluationContext context = mock(RuleEvaluationContext.class); tested.evaluate(ruleSet, context); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(context)); }
|
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(); }
|
@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")); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@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()); }
|
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(); }
|
@Test public void testSelectProfileInstances() { Annotation qualifier = mock(Annotation.class); tested.selectProfileInstances(qualifier); verify(profileInstances, times(1)).select(eq(qualifier)); }
|
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testDestroy() { tested.destroy(); verify(profileInstances, times(1)).destroyAll(); }
|
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(); }
|
@Test public void testStart() { tested.start(); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); }
|
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(); }
|
@Test public void testRollback() { tested.rollback(); verify(lifecycle, times(1)).rollback(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).start(); }
|
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(); }
|
@Test public void testComplete() { tested.complete(); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); }
|
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(); }
|
@Test public void testOnMouseDown() { tested.onMouseDown(mock(CanvasMouseDownEvent.class)); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); }
|
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(); }
|
@Test public void testOnMouseUp() { tested.onMouseUp(mock(CanvasMouseUpEvent.class)); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); }
|
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); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@Test public void testInit() { tested.init(); assertEquals(tested, lifecycle.getTarget()); verify(lifecycle, never()).start(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).complete(); }
|
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(); }
|
@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(); }
|
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(); }
|
@Test public void testComplete() { tested.start(); tested.complete(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).complete(); verify(commandManager, never()).rollback(); }
|
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(); }
|
@Test public void testRollback() { tested.start(); tested.rollback(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).rollback(); verify(commandManager, never()).complete(); }
|
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(); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@Test public void testUndo() { tested.undo(); verify(commandManager, times(1)).undo(); verify(commandManager, never()).execute(any()); verify(commandManager, never()).allow(any()); }
|
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(); }
|
@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)); }
|
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(); }
|
@Test public void testDestroy() { tested.start(); tested.destroy(); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroyAll(); }
|
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(); }
|
@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)); }
|
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(); }
|
@Test public void testSetSession() { ClientSession session = mock(ClientSession.class); tested.setSession(session); verify(commandRegistry, times(1)).setRegistryChangeListener(any()); }
|
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(); }
|
@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(); }
|
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(); }
|
@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(); }
|
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(); }
|
@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(); }
|
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(); }
|
@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)); }
|
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(); }
|
@Test public void testClear() { tested.clear(); verify(state, times(1)).clear(); }
|
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(); }
|
@Test public void testAddElement() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); }
|
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(); }
|
@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)); }
|
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); }
|
@Test public void testShow() { view.show(Optional.empty()); verify(viewElementCSSClasses).add(OPEN); verify(viewElement).focus(); }
|
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(); }
|
@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()); }
|
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); }
|
@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)); }
|
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); }
|
@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); }
|
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(); }
|
@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)); }
|
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(); }
|
@Test public void testDestroy() { tested.destroy(); verify(preferencesHolders, times(1)).destroyAll(); }
|
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); }
|
@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)); }
|
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); }
|
@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); }
|
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); }
|
@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)); }
|
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); }
|
@Test public void testHide() { view.hide(); verify(viewElementCSSClasses).remove(OPEN); }
|
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); }
|
@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)); }
|
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(); }
|
@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)); }
|
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(); }
|
@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)); }
|
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); }
|
@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); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public Point2D getNext(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); Point2D[] offset = {new Point2D(PADDING_X, 0)}; Point2D[] parentOffset = {new Point2D(0, 0)}; double maxNodeY[] = {0}; if (root.getOutEdges().size() > 0) { root.getOutEdges().stream() .filter(e -> e.getContent() instanceof ViewConnector) .filter(e -> null != e.getTargetNode() && !e.getTargetNode().equals(newNode)) .forEach(n -> { final Node<View<?>, Edge> node = n.getTargetNode(); final Point2D nodePos = GraphUtils.getPosition(node.getContent()); final Point2D rootPos = GraphUtils.getPosition(root.getContent()); if (nodePos.getY() > maxNodeY[0]) { maxNodeY[0] = nodePos.getY(); final double[] nodeSize = GraphUtils.getNodeSize(node.getContent()); offset[0].setY(maxNodeY[0] + nodeSize[1] - rootPos.getY()); } }); offset[0].setY(offset[0].getY() + parentOffset[0].getY() + PADDING_Y); } else { offset[0].setY(parentOffset[0].getY() - (newNodeSize[1] - rootSize[1]) / 2); } offset[0].setX(offset[0].getX() + PADDING_X); final Point2D offsetCoordinates = new Point2D(offset[0].getX(), offset[0].getY()); final Point2D rootNodeCoordinates = new Point2D(rootBounds[0], rootBounds[1]); return getNext(canvasHandler, root, rootSize[0], rootSize[1], newNodeSize[0], newNodeSize[1], offsetCoordinates, rootNodeCoordinates ); } @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); }
|
@Test @Ignore @SuppressWarnings("unchecked") public void getNextFromRoot() { Node node1 = mock(Node.class); Bounds boundsNode1 = Bounds.create(100d, 100d, 300d, 200d); View viewNode1 = mock(View.class); when(node1.getContent()).thenReturn(viewNode1); when(viewNode1.getBounds()).thenReturn(boundsNode1); Node node2 = mock(Node.class); Bounds boundsNode2 = Bounds.create(100d, 100d, 300d, 200d); View viewNode2 = mock(View.class); when(node2.getContent()).thenReturn(viewNode2); when(viewNode2.getBounds()).thenReturn(boundsNode2); Node nodeRoot = mock(Node.class); double rootWidth = 40d; double rootHeight = 40d; Bounds rootBounds = Bounds.create(0d, 0d, rootWidth, rootHeight); View rootView = mock(View.class); when(nodeRoot.getContent()).thenReturn(rootView); when(rootView.getBounds()).thenReturn(rootBounds); List<Node> nodes = new ArrayList<>(); List<Edge> edges = new ArrayList<>(); Edge edge = mock(Edge.class); edges.add(edge); when(nodeRoot.getOutEdges()).thenReturn(edges); when(edge.getTargetNode()).thenReturn(node1); when(nodeRoot.getContent()).thenReturn(rootView); nodes.add(nodeRoot); when(graph.nodes()).thenReturn(nodes); when(node2.getInEdges()).thenReturn(edges); when(nodeRoot.asNode()).thenReturn(nodeRoot); Point2D next = canvasLayoutUtils.getNext(canvasHandler, nodeRoot, node2); assertTrue(next.getX() > rootWidth); assertTrue(next.getY() > NEW_NODE_HEIGHT); }
|
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); }
|
@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)); }
|
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); }
|
@Test public void testRegisterOnCloseHandler() { final EventListener<Event> onKeyDown = (e) -> {}; doReturn(onKeyDown).when(view).onKeyDown(); view.registerOnCloseHandler(); verify(viewElement).addEventListener(KEYDOWN, onKeyDown, false); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject, final String modelName, final String namespace) { return findDefinitionsByNamespace(workspaceProject, namespace) .map(Definitions::getItemDefinition) .orElse(emptyList()); } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); static final QName NAMESPACE; }
|
@Test public void testGetImportedItemDefinitionsByNamespace() { final WorkspaceProject workspaceProject = mock(WorkspaceProject.class); final String modelName = "model1"; final String namespace = ": final Path path1 = makePath("../file1.dmn"); final Path path2 = makePath("../file2.dmn"); final Path path3 = makePath("../file3.dmn"); final Path path4 = makePath("../file4.dmn"); final InputStream inputStream1 = mock(InputStream.class); final InputStream inputStream2 = mock(InputStream.class); final InputStream inputStream3 = mock(InputStream.class); final InputStreamReader inputStreamReader1 = mock(InputStreamReader.class); final InputStreamReader inputStreamReader2 = mock(InputStreamReader.class); final InputStreamReader inputStreamReader3 = mock(InputStreamReader.class); final Definitions definitions1 = mock(Definitions.class); final Definitions definitions2 = mock(Definitions.class); final Definitions definitions3 = mock(Definitions.class); final ItemDefinition itemDefinition1 = mock(ItemDefinition.class); final ItemDefinition itemDefinition2 = mock(ItemDefinition.class); final List<Path> paths = asList(path1, path2, path3, path4); when(pathsHelper.getDMNModelsPaths(any())).thenReturn(paths); doReturn(Optional.of(inputStream1)).when(helper).loadPath(path1); doReturn(Optional.of(inputStream2)).when(helper).loadPath(path2); doReturn(Optional.of(inputStream3)).when(helper).loadPath(path3); doReturn(inputStreamReader1).when(helper).toInputStreamReader(inputStream1); doReturn(inputStreamReader2).when(helper).toInputStreamReader(inputStream2); doReturn(inputStreamReader3).when(helper).toInputStreamReader(inputStream3); doReturn(Optional.empty()).when(helper).loadPath(path4); when(marshaller.unmarshal(inputStreamReader1)).thenReturn(definitions1); when(marshaller.unmarshal(inputStreamReader2)).thenReturn(definitions2); when(marshaller.unmarshal(inputStreamReader3)).thenReturn(definitions3); when(definitions1.getNamespace()).thenReturn(": when(definitions2.getNamespace()).thenReturn(": when(definitions3.getNamespace()).thenReturn(": when(definitions1.getItemDefinition()).thenReturn(asList(itemDefinition1, itemDefinition2)); final List<ItemDefinition> actualItemDefinitions = helper.getImportedItemDefinitionsByNamespace(workspaceProject, modelName, namespace); final List<ItemDefinition> expectedItemDefinitions = asList(itemDefinition1, itemDefinition2); assertEquals(expectedItemDefinitions, actualItemDefinitions); }
|
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(); }
|
@Test @SuppressWarnings("unchecked") public void testAddChildShape() { tested.addChild(parentShape, childShape); verify(canvasView, times(1)).addChild(eq(parentShapeView), eq(childShapeView)); }
|
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(); }
|
@Test @SuppressWarnings("unchecked") public void testDeleteChildShape() { tested.deleteChild(parentShape, childShape); verify(canvasView, times(1)).deleteChild(eq(parentShapeView), eq(childShapeView)); }
|
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(); }
|
@Test @SuppressWarnings("unchecked") public void testDock() { tested.dock(parentShape, childShape); verify(canvasView, times(1)).dock(eq(parentShapeView), eq(childShapeView)); }
|
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(); }
|
@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)); }
|
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(); }
|
@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()); }
|
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); }
|
@Test public void testReturnFocusToPanel() { view.setOnClosedByKeyboardCallback(canBeClosedByKeyboardConsumer); view.returnFocusToPanel(); verify(canBeClosedByKeyboardConsumer).accept(view); }
|
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(); }
|
@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()); }
|
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(); }
|
@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(); }
|
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(); }
|
@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(); }
|
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(); }
|
@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()); }
|
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(); }
|
@Test public void testRegisterElement() { tested.init(canvasHandler); assertFalse(isRegistered(element)); tested.register(element); assertTrue(isRegistered(element)); }
|
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(); }
|
@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()); }
|
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(); }
|
@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)); }
|
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(); }
|
@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)); }
|
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(); }
|
@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)); }
|
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(); }
|
@Test public void testGetElement() { final HTMLElement element = mock(HTMLElement.class); when(popover.getElement()).thenReturn(element); final HTMLElement actual = popover.getElement(); assertEquals(element, actual); }
|
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(); }
|
@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()); }
|
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); }
|
@Test public void onPlaceGainFocusEvent() { clipboardControlCleaner.onPlaceGainFocusEvent(placeLostFocusEvent); verify(clipboardControl, times(1)).clear(); }
|
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); }
|
@Test public void testRemove() { localClipboardControl.set(graphInstance.startNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.remove(graphInstance.startNode); assertFalse(localClipboardControl.hasElements()); }
|
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); }
|
@Test public void testClear() { localClipboardControl.set(graphInstance.startNode, graphInstance.intermNode, graphInstance.endNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.clear(); assertFalse(localClipboardControl.hasElements()); }
|
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); }
|
@Test public void testGetParent() { localClipboardControl.set(graphInstance.startNode); String parentUUID = localClipboardControl.getParent(graphInstance.startNode.getUUID()); assertEquals(parentUUID, graphInstance.parentNode.getUUID()); }
|
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); }
|
@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); }
|
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; }
|
@Test public void testBind() { control.bind(session); verify(keyboardControl, times(2)) .addKeyShortcutCallback(any(KeyboardControl.KeyShortcutCallback.class)); }
|
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; }
|
@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)); }
|
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(); }
|
@Test @SuppressWarnings("unchecked") public void testSetOnClosedByKeyboardCallbackNullControl() { popover.setOnClosedByKeyboardCallback(callback); verify(view, never()).setOnClosedByKeyboardCallback(any(Consumer.class)); }
|
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; }
|
@Test public void testSetCommandManagerProvider() { control.setCommandManagerProvider(commandManagerProvider); verify(textEditorBox).setCommandManagerProvider(eq(commandManagerProvider)); }
|
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; }
|
@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); }
|
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(); }
|
@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)); }
|
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(); }
|
@Test public void testDestroy() { tested.destroy(); verify(flowActionsToolboxFactory, times(1)).destroyAll(); verify(morphActionsToolboxFactory, times(1)).destroyAll(); verify(commonActionsToolboxFactory, times(1)).destroyAll(); }
|
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; }
|
@Test public void testInitnable() { tested.init(canvasHandler); assertEquals(canvasHandler, tested.getCanvasHandler()); }
|
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; }
|
@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)); }
|
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; }
|
@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(); }
|
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(); }
|
@Test @SuppressWarnings("unchecked") public void testShowNullControl() { popover.show(); verify(view, never()).show(any(Optional.class)); }
|
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); }
|
@Test public void checkPriorityEnsuresCatchAllOperation() { assertEquals(TextPropertyProviderFactory.CATCH_ALL_PRIORITY, provider.getPriority()); }
|
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); }
|
@Test @SuppressWarnings("unchecked") public void checkSupportsAllElements() { assertTrue(provider.supports(element)); }
|
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); }
|
@Test public void checkReadGetsNameFromPropertyMetaData() { provider.getText(element); verify(definitionUtils).getName(eq(definition)); }
|
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); }
|
@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)); }
|
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); }
|
@Test public void checkMatch() { final boolean match = KeysMatcher.doKeysMatch(keysActual.keys, keysExpected.keys); assertEquals(matches, match); }
|
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(); }
|
@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)); }
|
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(); }
|
@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()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.