src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void addFieldChangeHandler(FieldChangeHandler handler) { formRenderer.addFieldChangeHandler(handler); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testAddFieldChangeHandler() { FieldChangeHandler handler = mock(FieldChangeHandler.class); subFormWidget.addFieldChangeHandler(handler); verify(formRenderer).addFieldChangeHandler(same(handler)); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void setReadOnly(boolean readOnly) { formRenderer.switchToMode(readOnly ? RenderMode.READ_ONLY_MODE : RenderMode.EDIT_MODE); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testSetReadOnly() { subFormWidget.setReadOnly(true); verify(formRenderer).switchToMode(eq(RenderMode.READ_ONLY_MODE)); subFormWidget.setReadOnly(false); verify(formRenderer).switchToMode(eq(RenderMode.EDIT_MODE)); }
|
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public boolean isValid() { return formRenderer.isValid(); } void render(FormRenderingContext renderingContext); @Override Object getValue(); @Override void setValue(Object value); @Override void clear(); @Override void flush(); @Override void addFieldChangeHandler(FieldChangeHandler handler); void setReadOnly(boolean readOnly); boolean isValid(); }
|
@Test public void testIsValid() { subFormWidget.isValid(); verify(formRenderer).isValid(); }
|
MultipleSubFormFieldRenderer extends FieldRenderer<MultipleSubFormFieldDefinition, FieldSetFormGroup> { @Override protected FormGroup getFormGroup(RenderMode renderMode) { FieldSetFormGroup formGroup = formGroupsInstance.get(); multipleSubFormWidget.config(field, renderingContext); formGroup.render(multipleSubFormWidget, field); return formGroup; } @Override String getName(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); multipleSubFormWidget.config(any(), any()); verify(formGroup).render(any(), any()); }
|
DecisionServiceSVGShapeView extends SVGShapeViewImpl { public DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler) { final HandlerManager handlerManager = getHandlerManager(); final HandlerRegistration dragStartRegistration = handlerManager.addHandler(MoveDividerStartEvent.TYPE, event -> dragHandler.start(buildDragEvent(event))); final HandlerRegistration dragStepRegistration = handlerManager.addHandler(MoveDividerStepEvent.TYPE, event -> dragHandler.handle(buildDragEvent(event))); final HandlerRegistration dragEndRegistration = handlerManager.addHandler(MoveDividerEndEvent.TYPE, event -> dragHandler.end(buildDragEvent(event))); final HandlerRegistration[] registrations = new HandlerRegistration[]{dragStartRegistration, dragStepRegistration, dragEndRegistration}; getEventHandlerManager().addHandlersRegistration(ViewEventType.DRAG, registrations); return this; } DecisionServiceSVGShapeView(final String name,
final SVGPrimitiveShape svgPrimitive,
final double width,
final double height,
final boolean resizable); DecisionServiceSVGShapeView addDividerDragHandler(final DragHandler dragHandler); double getDividerLineY(); void setDividerLineY(final double y); @Override //Override to increase visibility for Unit Tests HandlerManager getHandlerManager(); @Override void destroy(); }
|
@Test public void testAddDividerDragHandler() { view.addDividerDragHandler(dragHandler); final HandlerManager handlerManager = view.getHandlerManager(); assertThat(handlerManager.isEventHandled(MoveDividerStartEvent.TYPE)).isTrue(); assertThat(handlerManager.isEventHandled(MoveDividerStepEvent.TYPE)).isTrue(); assertThat(handlerManager.isEventHandled(MoveDividerEndEvent.TYPE)).isTrue(); assertThat(handlerManager.getHandlerCount(MoveDividerStartEvent.TYPE)).isEqualTo(1); assertThat(handlerManager.getHandlerCount(MoveDividerStepEvent.TYPE)).isEqualTo(1); assertThat(handlerManager.getHandlerCount(MoveDividerEndEvent.TYPE)).isEqualTo(1); handlerManager.getHandler(MoveDividerStartEvent.TYPE, 0).onMoveDividerStart(new MoveDividerStartEvent(view, nodeDragStartEvent)); verify(dragHandler).start(any(DragEvent.class)); handlerManager.getHandler(MoveDividerStepEvent.TYPE, 0).onMoveDividerStep(new MoveDividerStepEvent(view, nodeDragMoveEvent)); verify(dragHandler).handle(any(DragEvent.class)); handlerManager.getHandler(MoveDividerEndEvent.TYPE, 0).onMoveDividerEnd(new MoveDividerEndEvent(view, nodeDragEndEvent)); verify(dragHandler).end(any(DragEvent.class)); }
@Test public void testShapeControlResizeHandlerMoveDividerEvents() { final MoveDividerControlHandle moveDividerControlHandle = getMoveDividerControlHandle(); view.addDividerDragHandler(dragHandler); moveDividerControlHandle.getControl().fireEvent(nodeDragStartEvent); verify(dragHandler).start(any(DragEvent.class)); moveDividerControlHandle.getControl().fireEvent(nodeDragMoveEvent); verify(dragHandler).handle(any(DragEvent.class)); moveDividerControlHandle.getControl().fireEvent(nodeDragEndEvent); verify(dragHandler).end(any(DragEvent.class)); }
|
DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); decimalBox.setId(inputId); decimalBox.setPlaceholder(field.getPlaceHolder()); decimalBox.setMaxLength(field.getMaxLength()); decimalBox.setEnabled(!field.getReadOnly()); formGroup.render(inputId, decimalBox.asWidget(), field); registerFieldRendererPart(decimalBox); } return formGroup; } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(decimalBox).setId(any()); verify(decimalBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(decimalBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(decimalBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(decimalBox).asWidget(); verify(formGroup).render(anyString(), any(), eq(fieldDefinition)); }
|
DecimalBoxFieldRenderer extends FieldRenderer<DecimalBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } @Inject DecimalBoxFieldRenderer(DecimalBox decimalBox); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetConverter() { checkConverter(Float.class.getName(), FloatToDoubleConverter.class); checkConverter(float.class.getName(), FloatToDoubleConverter.class); checkConverter(BigDecimal.class.getName(), BigDecimalToDoubleConverter.class); }
|
IntegerBoxFieldRenderer extends FieldRenderer<IntegerBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { Widget widget; String inputId = generateUniqueId(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { widget = new HTML(); widget.getElement().setId(inputId); } else { integerBox.setId(inputId); integerBox.setPlaceholder(field.getPlaceHolder()); integerBox.setMaxLength(field.getMaxLength()); integerBox.setEnabled(!field.getReadOnly()); widget = integerBox.asWidget(); } DefaultFormGroup formGroup = formGroupsInstance.get(); formGroup.render(inputId, widget, field); registerFieldRendererPart(widget); return formGroup; } @Inject IntegerBoxFieldRenderer(IntegerBox integerBox); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(integerBox).setId(any()); verify(integerBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(integerBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(integerBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(integerBox).asWidget(); verify(formGroup).render(anyString(), any(), eq(fieldDefinition)); }
|
IntegerBoxFieldRenderer extends FieldRenderer<IntegerBoxFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { return ValueConvertersFactory.getConverterForType(field.getStandaloneClassName()); } @Inject IntegerBoxFieldRenderer(IntegerBox integerBox); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetConverter() { checkConverter(BigInteger.class.getName(), BigIntegerToLongConverter.class); checkConverter(Byte.class.getName(), ByteToLongConverter.class); checkConverter(byte.class.getName(), ByteToLongConverter.class); checkConverter(Integer.class.getName(), IntegerToLongConverter.class); checkConverter(int.class.getName(), IntegerToLongConverter.class); checkConverter(Short.class.getName(), ShortToLongConverter.class); checkConverter(short.class.getName(), ShortToLongConverter.class); }
|
AbstractListBoxFieldRenderer extends SelectorFieldRenderer<FIELD, OPTION, TYPE> implements RequiresValueConverter { @Override protected void refreshInput(Map<TYPE, String> optionsValues, TYPE selectedValue) { List<TYPE> values = optionsValues.keySet().stream().collect(Collectors.toList()); if (field.getAddEmptyOption()) { if (!values.contains(null)) { values.add(0, null); optionsValues.put(null, translationService.getTranslation(FormRenderingConstants.ListBoxFieldRendererEmptyOptionText)); } else { Collections.swap(values, values.indexOf(null), 0); } } if (widgetList.getValue() == null && optionsValues.containsKey(selectedValue)) { widgetList.setValue(selectedValue); } optionsRenderer.setValues(optionsValues); widgetList.setAcceptableValues(values); } AbstractListBoxFieldRenderer(TranslationService translationService); @Override String getName(); abstract TYPE getEmptyValue(); @Override Converter getConverter(); }
|
@Test public void testRefreshInputDontAddNullOption() { when(field.getAddEmptyOption()).thenReturn(false); renderer.refreshInput(options, null); verify(field).getAddEmptyOption(); verify(translationService, never()).getTranslation(FormRenderingConstants.ListBoxFieldRendererEmptyOptionText); assertFalse(options.containsValue(null)); verify(optionsRenderer).setValues(options); verify(valueListBox).setAcceptableValues(any()); }
@Test public void testRefreshInputAddNullOption() { when(field.getAddEmptyOption()).thenReturn(true); renderer.refreshInput(options, null); verify(field).getAddEmptyOption(); verify(translationService).getTranslation(FormRenderingConstants.ListBoxFieldRendererEmptyOptionText); assertTrue(options.containsValue(null)); verify(optionsRenderer).setValues(options); verify(valueListBox).setAcceptableValues(any()); }
@Test public void testRefreshInputAddExistingNullOption() { when(field.getAddEmptyOption()).thenReturn(true); options.put(null, "null"); renderer.refreshInput(options, null); verify(field).getAddEmptyOption(); verify(translationService, never()).getTranslation(FormRenderingConstants.ListBoxFieldRendererEmptyOptionText); verify(optionsRenderer).setValues(options); verify(valueListBox).setAcceptableValues(any()); }
|
TextAreaFieldRenderer extends FieldRenderer<TextAreaFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { formGroup.render(new HTML(), field); } else { String inputId = generateUniqueId(); textArea.setId(inputId); textArea.setName(fieldNS); textArea.setPlaceholder(field.getPlaceHolder()); textArea.setVisibleLines(field.getRows()); textArea.setEnabled(!field.getReadOnly()); formGroup.render(inputId, textArea, field); registerFieldRendererPart(textArea); } return formGroup; } @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(textArea).setId(any()); verify(textArea).setName(anyString()); verify(textArea).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(textArea).setVisibleLines(eq(fieldDefinition.getRows())); verify(textArea).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(formGroup).render(anyString(), eq(textArea), eq(fieldDefinition)); }
|
MultipleSelectorFieldRenderer extends FieldRenderer<AbstractMultipleSelectorFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); final List<TYPE> values = field.getListOfValues(); selector.init(searchService, new MultipleLiveSearchSelectionHandler<>(field.getMaxElementsOnTitle())); selector.setMaxItems(field.getMaxDropdownElements()); selector.setEnabled(!field.getReadOnly() && renderingContext.getRenderMode().equals(RenderMode.EDIT_MODE)); selector.setFilterEnabled(field.getAllowFilter()); selector.setClearSelectionEnabled(field.getAllowClearSelection()); if (renderMode.equals(RenderMode.PRETTY_MODE)) { selector.setEnabled(false); } formGroup.render(selector.asWidget(), field); return formGroup; } @Inject MultipleSelectorFieldRenderer(MultipleSelectorInput<TYPE> selector,
TranslationService translationService); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); selector.init(any(), any()); verify(selector).setMaxItems(fieldDefinition.getMaxDropdownElements()); verify(selector).setEnabled(true); verify(selector).setFilterEnabled(fieldDefinition.getAllowFilter()); verify(selector).setClearSelectionEnabled(fieldDefinition.getAllowClearSelection()); verify(formGroup).render(any(), eq(fieldDefinition)); }
|
MultipleSelectorInput implements IsWidget,
MultipleSelectorInputView.Presenter<TYPE> { @Override public void setValue(List<TYPE> values) { setValue(values, false); } @Inject MultipleSelectorInput(MultipleSelectorInputView view,
LiveSearchDropDown<TYPE> selector); void init(LiveSearchService<TYPE> searchService,
MultipleLiveSearchSelectionHandler<TYPE> searchSelectionHandler); @Override void setValue(List<TYPE> values); @Override void setValue(List<TYPE> values,
boolean fireEvents); @Override List<TYPE> getValue(); @Override Widget asWidget(); @Override HandlerRegistration addValueChangeHandler(ValueChangeHandler<List<TYPE>> handler); @Override void fireEvent(GwtEvent<?> event); @Override IsWidget getSelector(); void setMaxItems(Integer maxItems); void setEnabled(boolean enabled); void setFilterEnabled(Boolean allowFilter); void setClearSelectionEnabled(Boolean allowClearSelection); }
|
@Test public void testSetSameComponentValues() { List<String> values = new ArrayList<>(); input.setValue(values); verify(searchSelectionHandler, never()).clearSelection(); verify(dropDown, never()).setSelectedItem(anyString()); }
@Test public void testSetComponentValues() { List<String> values = Arrays.asList("a", "b", "c"); input.setValue(values); verify(dropDown, times(1)).clearSelection(); verify(dropDown, times(3)).setSelectedItem(anyString()); }
|
MultipleInputFieldRenderer extends FieldRenderer<AbstractMultipleInputFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); input.setPageSize(field.getPageSize()); input.init(field.getStandaloneClassName()); if(field.getReadOnly() || !renderMode.equals(RenderMode.EDIT_MODE)) { setReadOnly(true); } formGroup.render(input.asWidget(), field); return formGroup; } @Inject MultipleInputFieldRenderer(MultipleInput input); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroup() { testGetFormGroup(false); }
|
MultipleInputFieldRenderer extends FieldRenderer<AbstractMultipleInputFieldDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected void setReadOnly(boolean readOnly) { input.setReadOnly(readOnly); } @Inject MultipleInputFieldRenderer(MultipleInput input); @Override String getName(); @Override Converter getConverter(); }
|
@Test public void testGetFormGroupReadOnly() { fieldDefinition.setReadOnly(true); testGetFormGroup(true); }
|
MultipleInput implements IsWidget,
MultipleInputView.Presenter<TYPE> { @Override public void setValue(List<TYPE> value) { setValue(value, false); } @Inject MultipleInput(MultipleInputView<TYPE> view, MultipleInputComponent<TYPE> component); @Override MultipleInputComponent getComponent(); @Override List<TYPE> getValue(); @Override void setValue(List<TYPE> value); @Override void setValue(List<TYPE> values,
boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(ValueChangeHandler<List<TYPE>> handler); @Override void fireEvent(GwtEvent<?> event); @Override Widget asWidget(); void init(String typeName); void setPageSize(Integer pageSize); void setReadOnly(boolean readOnly); }
|
@Test public void testSetSameComponentValues() { List<String> values = new ArrayList<>(); input.setValue(values); verify(component, never()).setValues(values); }
@Test public void testSetComponentValues() { List<String> values = Arrays.asList("a", "b", "c"); input.setValue(values); verify(component).setValues(values); }
|
MultipleInputComponent implements MultipleInputComponentView.Presenter<TYPE>,
IsElement { public void setValues(List<TYPE> values) { selectedValues.clear(); tableValues.clear(); tableValues = values.stream() .map(value -> new TableEntry<>(value)) .collect(Collectors.toList()); doInit(); init(modelType); } @Inject MultipleInputComponent(MultipleInputComponentView view,
EditableColumnGeneratorManager columnGeneratorManager); @PostConstruct void init(); @Override HTMLElement getElement(); void init(String modelType); @Override EditableColumnGenerator<TYPE> getColumnGenerator(); @Override void notifyChange(int index,
TYPE value); void setPageSize(Integer pageSize); @Override void selectValue(TableEntry<TYPE> entry); @Override void promoteSelectedValues(); @Override void degradeSelectedValues(); @Override void removeSelectedValues(); @Override Boolean isSelected(TableEntry<TYPE> object); List<TYPE> getValues(); void setValues(List<TYPE> values); void setReadOnly(boolean readOnly); @Override boolean isReadOnly(); @Override void newElement(); @Override Integer getPageSize(); @Override AbstractDataProvider<TableEntry<TYPE>> getProvider(); void setValueChangedCommand(Command valueChangedCommand); }
|
@Test public void testSetValues() { List<String> values = Arrays.asList("a", "b", "c"); component.setValues(values); Assertions.assertThat(component.getSelectedValues()) .isEmpty(); Assertions.assertThat(component.getTableValues()) .isNotEmpty() .hasSize(values.size()); Assertions.assertThat(component.getValues()) .isNotEmpty() .containsAll(values); verify(component, times(2)).doInit(); verify(component, times(2)).init(anyString()); }
|
AbstractNumericEditableColumnGenerator extends AbstractEditableColumnGenerator<NUMBER> { protected abstract boolean doValidate(String flatValue, TableEntry<NUMBER> model, CellEditionHandler<NUMBER> cellEditionHandler); AbstractNumericEditableColumnGenerator(TranslationService translationService); }
|
@Test public void testDoValidateNoErrors() { String correctFlatValue = getCorrectFlatValue(); assertTrue(generator.doValidate(correctFlatValue, tableEntry, cellEditionHandler)); verify(cellEditionHandler, never()).showValidationError(anyString()); }
@Test public void testDoValidateWithErrors() { String wrongFlatValue = getWrongFlatValue(); assertFalse(generator.doValidate(wrongFlatValue, tableEntry, cellEditionHandler)); verify(cellEditionHandler, times(1)).showValidationError(anyString()); }
|
AbstractNumericEditableColumnGenerator extends AbstractEditableColumnGenerator<NUMBER> { protected abstract NUMBER doConvert(String flatValue); AbstractNumericEditableColumnGenerator(TranslationService translationService); }
|
@Test public void testDoConvert() { String correctFlatValue = getCorrectFlatValue(); TYPE correctValue = getCorrectValue(); assertEquals(correctValue, generator.doConvert(correctFlatValue)); }
|
AbstractEditableColumnGenerator implements EditableColumnGenerator<TYPE> { protected abstract Column<TableEntry<TYPE>, ?> getEditableColumn(UberfirePagedTable<TableEntry<TYPE>> table, CellEditionHandler<TYPE> cellEditionHandler); AbstractEditableColumnGenerator(TranslationService translationService); @Override void registerColumn(UberfirePagedTable<TableEntry<TYPE>> table,
CellEditionHandler<TYPE> cellEditionHandler,
boolean readOnly); }
|
@Test public void testGetEditableColumn() { testGetColumn(false); }
|
MoveDividerEndEvent extends AbstractWiresDragEvent<MoveDividerEndHandler> { @Override public Type<MoveDividerEndHandler> getAssociatedType() { return TYPE; } MoveDividerEndEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerEndHandler> getAssociatedType(); static final Type<MoveDividerEndHandler> TYPE; }
|
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerEndEvent.TYPE); }
|
AbstractEditableColumnGenerator implements EditableColumnGenerator<TYPE> { protected abstract Column<TableEntry<TYPE>, ?> getReadOnlyColumn(); AbstractEditableColumnGenerator(TranslationService translationService); @Override void registerColumn(UberfirePagedTable<TableEntry<TYPE>> table,
CellEditionHandler<TYPE> cellEditionHandler,
boolean readOnly); }
|
@Test public void testGetReadOnlyColumn() { testGetColumn(true); }
|
CheckBoxFieldRenderer extends FieldRenderer<CheckBoxFieldDefinition, CheckBoxFormGroup> { @Override protected FormGroup getFormGroup(RenderMode renderMode) { checkbox.setId(generateUniqueId()); checkbox.setName(fieldNS); checkbox.setEnabled(!field.getReadOnly() && renderingContext.getRenderMode().equals(RenderMode.EDIT_MODE)); CheckBoxFormGroup formGroup = formGroupsInstance.get(); formGroup.render(checkbox, field); registerFieldRendererPart(checkbox); return formGroup; } @Override String getName(); }
|
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(checkBox).setId(any()); verify(checkBox).setName(anyString()); verify(checkBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(formGroup).render(eq(checkBox), eq(fieldDefinition)); }
|
FieldLayoutComponent implements FormLayoutComponent,
LayoutDragComponent { @Override public String getDragComponentTitle() { String name = ""; if (field.getBinding() != null) { name = field.getBinding(); } else { name = translationService.getTranslation(fieldRenderer.getName()); if (name == null || name.isEmpty()) { name = fieldRenderer.getName(); } } return name; } @Inject FieldLayoutComponent(FieldRendererManager fieldRendererManager, TranslationService translationService); void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String getDragComponentTitle(); @Override IsWidget getPreviewWidget(RenderingContext ctx); @Override IsWidget getShowWidget(RenderingContext ctx); Optional<IsWidget> getContentPart(String partId, RenderingContext componentContext); void addComponentParts(LayoutComponent component); String getFieldId(); String getFormId(); FieldRenderer getFieldRenderer(); FieldDefinition getField(); @PreDestroy void destroy(); }
|
@Test public void testGetDragComponentTitle() { String result = component.getDragComponentTitle(); verify(renderer, never()).getName(); verify(translationService, never()).getTranslation(anyString()); Assertions.assertThat(result) .isEqualTo(NAME); }
@Test public void testUnBoundGetDragComponentTitleWithTranslation() { field.setBinding(null); component.getDragComponentTitle(); verify(renderer, times(2)).getName(); verify(translationService).getTranslation(anyString()); }
@Test public void testUnBoundGetDragComponentTitleWithoutTranslation() { when(translationService.getTranslation(anyString())).thenReturn(NAME); field.setBinding(null); component.getDragComponentTitle(); verify(renderer).getName(); verify(translationService).getTranslation(anyString()); }
|
FieldLayoutComponent implements FormLayoutComponent,
LayoutDragComponent { @Override public IsWidget getPreviewWidget(RenderingContext ctx) { return generateContent(ctx); } @Inject FieldLayoutComponent(FieldRendererManager fieldRendererManager, TranslationService translationService); void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String getDragComponentTitle(); @Override IsWidget getPreviewWidget(RenderingContext ctx); @Override IsWidget getShowWidget(RenderingContext ctx); Optional<IsWidget> getContentPart(String partId, RenderingContext componentContext); void addComponentParts(LayoutComponent component); String getFieldId(); String getFormId(); FieldRenderer getFieldRenderer(); FieldDefinition getField(); @PreDestroy void destroy(); }
|
@Test public void testGetPreviewWidget() { component.getPreviewWidget(mock(RenderingContext.class)); verify(renderer).renderWidget(); verify(content).clear(); verify(content).add(any(IsWidget.class)); }
|
FieldLayoutComponent implements FormLayoutComponent,
LayoutDragComponent { @Override public IsWidget getShowWidget(RenderingContext ctx) { return generateContent(ctx); } @Inject FieldLayoutComponent(FieldRendererManager fieldRendererManager, TranslationService translationService); void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String getDragComponentTitle(); @Override IsWidget getPreviewWidget(RenderingContext ctx); @Override IsWidget getShowWidget(RenderingContext ctx); Optional<IsWidget> getContentPart(String partId, RenderingContext componentContext); void addComponentParts(LayoutComponent component); String getFieldId(); String getFormId(); FieldRenderer getFieldRenderer(); FieldDefinition getField(); @PreDestroy void destroy(); }
|
@Test public void testGetShowWidget() { component.getShowWidget(mock(RenderingContext.class)); verify(renderer).renderWidget(); verify(content).clear(); verify(content).add(any(IsWidget.class)); }
|
FieldLayoutComponent implements FormLayoutComponent,
LayoutDragComponent { public void addComponentParts(LayoutComponent component) { Set<String> parts = fieldRenderer.getFieldParts(); component.removePartIf(partId -> !parts.contains(partId)); parts.forEach(component::addPartIfAbsent); } @Inject FieldLayoutComponent(FieldRendererManager fieldRendererManager, TranslationService translationService); void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String getDragComponentTitle(); @Override IsWidget getPreviewWidget(RenderingContext ctx); @Override IsWidget getShowWidget(RenderingContext ctx); Optional<IsWidget> getContentPart(String partId, RenderingContext componentContext); void addComponentParts(LayoutComponent component); String getFieldId(); String getFormId(); FieldRenderer getFieldRenderer(); FieldDefinition getField(); @PreDestroy void destroy(); }
|
@Test public void testAddExistingComponentPart() { LayoutComponent layoutComponent = new LayoutComponent(); component.addComponentParts(layoutComponent); Assertions.assertThat(layoutComponent.getParts()) .isNotEmpty() .hasSize(parts.size()) .anyMatch(part -> part.getPartId().equals(PART_1)) .anyMatch(part -> part.getPartId().equals(PART_2)) .anyMatch(part -> part.getPartId().equals(PART_3)); }
|
FieldLayoutComponent implements FormLayoutComponent,
LayoutDragComponent { public Optional<IsWidget> getContentPart(String partId, RenderingContext componentContext) { return Optional.ofNullable(fieldRenderer.getFieldPartWidget(partId)); } @Inject FieldLayoutComponent(FieldRendererManager fieldRendererManager, TranslationService translationService); void init(FormRenderingContext renderingContext,
FieldDefinition field); @Override String getDragComponentTitle(); @Override IsWidget getPreviewWidget(RenderingContext ctx); @Override IsWidget getShowWidget(RenderingContext ctx); Optional<IsWidget> getContentPart(String partId, RenderingContext componentContext); void addComponentParts(LayoutComponent component); String getFieldId(); String getFormId(); FieldRenderer getFieldRenderer(); FieldDefinition getField(); @PreDestroy void destroy(); }
|
@Test public void testGetContentPart() { RenderingContext renderingContext = mock(RenderingContext.class); Assertions.assertThat(component.getContentPart(PART_1, renderingContext)) .isNotNull() .isPresent(); Assertions.assertThat(component.getContentPart(PART_2, renderingContext)) .isNotNull() .isPresent(); Assertions.assertThat(component.getContentPart(PART_3, renderingContext)) .isNotNull() .isPresent(); Assertions.assertThat(component.getContentPart(UNEXISTING_PART, renderingContext)) .isNotNull() .isNotPresent(); }
|
FieldLabel implements IsElement,
FieldLabelView.Presenter { public void renderForInput(IsWidget isWidget, FieldDefinition fieldDefinition) { PortablePreconditions.checkNotNull("fieldDefinition", fieldDefinition); PortablePreconditions.checkNotNull("isWidget", isWidget); view.renderForInput(isWidget, fieldDefinition.getLabel(), fieldDefinition.getRequired(), fieldDefinition.getHelpMessage()); } @Inject FieldLabel(FieldLabelView view); void renderForInputId(String inputId,
FieldDefinition fieldDefinition); void renderForInput(IsWidget isWidget,
FieldDefinition fieldDefinition); @Override HTMLElement getElement(); }
|
@Test public void testRenderForInput() { assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> { fieldLabel.renderForInput(null, fieldDefinition); }).withMessage("Parameter named 'isWidget' should be not null!"); assertNeverRenderForInput(); assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> { fieldLabel.renderForInput(isWidget, null); }).withMessage("Parameter named 'fieldDefinition' should be not null!"); assertNeverRenderForInput(); fieldLabel.renderForInput(isWidget, fieldDefinition); verify(fieldDefinition).getLabel(); verify(fieldDefinition).getHelpMessage(); verify(fieldDefinition).getRequired(); verify(view).renderForInput(isWidget, FIELD_LABEL, FIELD_REQUIRED, FIELD_HELP); }
|
MoveDividerEndEvent extends AbstractWiresDragEvent<MoveDividerEndHandler> { @Override protected void dispatch(final MoveDividerEndHandler handler) { handler.onMoveDividerEnd(this); } MoveDividerEndEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerEndHandler> getAssociatedType(); static final Type<MoveDividerEndHandler> TYPE; }
|
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerEnd(eq(event)); }
|
FieldLabel implements IsElement,
FieldLabelView.Presenter { public void renderForInputId(String inputId, FieldDefinition fieldDefinition) { PortablePreconditions.checkNotNull("inputId", inputId); PortablePreconditions.checkNotNull("fieldDefinition", fieldDefinition); view.renderForInputId(inputId, fieldDefinition.getLabel(), fieldDefinition.getRequired(), fieldDefinition.getHelpMessage()); } @Inject FieldLabel(FieldLabelView view); void renderForInputId(String inputId,
FieldDefinition fieldDefinition); void renderForInput(IsWidget isWidget,
FieldDefinition fieldDefinition); @Override HTMLElement getElement(); }
|
@Test public void testRenderForInputId() { assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> { fieldLabel.renderForInputId(null, fieldDefinition); }).withMessage("Parameter named 'inputId' should be not null!"); assertNeverRenderForInputId(); assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> { fieldLabel.renderForInputId(INPUT_ID, null); }).withMessage("Parameter named 'fieldDefinition' should be not null!"); assertNeverRenderForInputId(); fieldLabel.renderForInputId(INPUT_ID, fieldDefinition); verify(fieldDefinition).getLabel(); verify(fieldDefinition).getHelpMessage(); verify(fieldDefinition).getRequired(); verify(view).renderForInputId(INPUT_ID, FIELD_LABEL, FIELD_REQUIRED, FIELD_HELP); }
|
FieldRequired implements FieldRequiredView.Presenter,
IsElement { @Override public HTMLElement getElement() { return view.getElement(); } @Inject FieldRequired(FieldRequiredView view); @Override HTMLElement getElement(); }
|
@Test public void testFunctionallity() { fieldRequired = new FieldRequired(view); fieldRequired.getElement(); verify(view).init(fieldRequired); verify(view).getElement(); }
|
DefaultFormGroup extends AbstractValidableFormGroup<DefaultFormGroupView> { public void render(String inputId, Widget widget, FieldDefinition fieldDefinition) { this.bindable = widget; view.render(inputId, widget, fieldDefinition); } @Inject DefaultFormGroup(DefaultFormGroupView view); void render(String inputId,
Widget widget,
FieldDefinition fieldDefinition); }
|
@Test public void testRenderWithInputId() { formGroup.render(INPUT_ID, widget, fieldDefinition); verify(view).render(INPUT_ID, widget, fieldDefinition); formGroup.getElement(); verify(view).getElement(); }
|
DynamicFormRenderer implements IsWidget,
IsFormView { protected void doBind(FieldRenderer renderer) { if (isInitialized() && renderer.getFormField() != null) { if (renderer instanceof RequiresValueConverter) { Converter valueConverter = ((RequiresValueConverter) renderer).getConverter(); formHandler.registerInput(renderer.getFormField(), valueConverter); } else { formHandler.registerInput(renderer.getFormField()); } } } @Inject DynamicFormRenderer(DynamicFormRendererView view,
FormHandlerGeneratorManager formHandlerGenerator,
DynamicFormModelGenerator dynamicFormModelGenerator); void renderDefaultForm(final Object model); void renderDefaultForm(final Object model,
RenderMode renderMode); void renderDefaultForm(final Object model,
final Command callback); void renderDefaultForm(final Object model,
final RenderMode renderMode,
final Command callback); void render(FormRenderingContext context); void bind(Object model); void addFieldChangeHandler(FieldChangeHandler handler); void addFieldChangeHandler(String fieldName,
FieldChangeHandler handler); void unBind(); void setModel(Object model); Object getModel(); void switchToMode(RenderMode renderMode); boolean isValid(); @Override Widget asWidget(); Form getCurrentForm(); void flush(); boolean isInitialized(); }
|
@Test public void testRenderMultipleTimes() { doBind(1); doBind(2); verify(formHandler).clear(); verify(view).clear(); }
|
DynamicFormRenderer implements IsWidget,
IsFormView { public void flush() { if (isInitialized()) { formHandler.maybeFlush(); } } @Inject DynamicFormRenderer(DynamicFormRendererView view,
FormHandlerGeneratorManager formHandlerGenerator,
DynamicFormModelGenerator dynamicFormModelGenerator); void renderDefaultForm(final Object model); void renderDefaultForm(final Object model,
RenderMode renderMode); void renderDefaultForm(final Object model,
final Command callback); void renderDefaultForm(final Object model,
final RenderMode renderMode,
final Command callback); void render(FormRenderingContext context); void bind(Object model); void addFieldChangeHandler(FieldChangeHandler handler); void addFieldChangeHandler(String fieldName,
FieldChangeHandler handler); void unBind(); void setModel(Object model); Object getModel(); void switchToMode(RenderMode renderMode); boolean isValid(); @Override Widget asWidget(); Form getCurrentForm(); void flush(); boolean isInitialized(); }
|
@Test public void testFlush() { doBind(1); renderer.flush(); verify(formHandler).maybeFlush(); }
@Test public void testFlushWithoutInitializing() { renderer.flush(); verify(formHandler, never()).maybeFlush(); }
|
DynamicFormRenderer implements IsWidget,
IsFormView { public Object getModel() { if (isInitialized()) { return formHandler.getModel(); } return null; } @Inject DynamicFormRenderer(DynamicFormRendererView view,
FormHandlerGeneratorManager formHandlerGenerator,
DynamicFormModelGenerator dynamicFormModelGenerator); void renderDefaultForm(final Object model); void renderDefaultForm(final Object model,
RenderMode renderMode); void renderDefaultForm(final Object model,
final Command callback); void renderDefaultForm(final Object model,
final RenderMode renderMode,
final Command callback); void render(FormRenderingContext context); void bind(Object model); void addFieldChangeHandler(FieldChangeHandler handler); void addFieldChangeHandler(String fieldName,
FieldChangeHandler handler); void unBind(); void setModel(Object model); Object getModel(); void switchToMode(RenderMode renderMode); boolean isValid(); @Override Widget asWidget(); Form getCurrentForm(); void flush(); boolean isInitialized(); }
|
@Test public void testGetModel() { doBind(1); renderer.getModel(); verify(formHandler).getModel(); }
@Test public void testGetModelWithoutInitializing() { renderer.getModel(); verify(formHandler, never()).getModel(); }
|
MapModelBindingHelper { public void initContext(MapModelRenderingContext context) { FormDefinition form = context.getRootForm(); Map<String, PropertyType> modelProperties = generateModelDefinition(form, context); Map<String, Object> content = DataBinder.forMap(modelProperties).getModel(); Map<String, Object> contextModel = context.getModel() != null ? context.getModel() : new HashMap<>(); prepareMapContent(content, form, contextModel, context); context.setModel(content); } @PostConstruct void initialize(); void initContext(MapModelRenderingContext context); void prepareMapContent(Map<String, Object> formData,
FormDefinition form,
Map<String, Object> contextData,
MapModelRenderingContext context); MapPropertyType getModeldefinitionFor(SubFormFieldDefinition subFormField,
MapModelRenderingContext context,
Map<String, Map<String, PropertyType>> availableModels); MapPropertyType getModeldefinitionFor(MultipleSubFormFieldDefinition subFormField,
MapModelRenderingContext context,
Map<String, Map<String, PropertyType>> availableModels); }
|
@Test public void testInitContextWithEmptyModel() { context.setModel(new HashMap<>()); helper.initContext(context); assertNotNull(context.getModel()); assertTrue(context.getModel() instanceof MapBindableProxy); MapBindableProxy model = (MapBindableProxy) context.getModel(); checkBindableProxy(model); assertNull(model.get(EMPLOYEE_NAME)); assertNull(model.get(EMPLOYEE_SURNAME)); assertNull(model.get(EMPLOYEE_AGE_BINDING)); assertNull(model.get(EMPLOYEE_BIRTHDAY)); assertNull(model.get(EMPLOYEE_MARRIED)); }
@Test public void testInitContextWithModel() { Map<String, Object> employeeMap = new HashMap<>(); employeeMap.put(EMPLOYEE_NAME, NAME); employeeMap.put(EMPLOYEE_SURNAME, SURNAME); employeeMap.put(EMPLOYEE_AGE_BINDING, AGE); employeeMap.put(EMPLOYEE_BIRTHDAY, BIRTHDAY); employeeMap.put(EMPLOYEE_MARRIED, MARRIED); Map<String, Object> addressMap = new HashMap<>(); addressMap.put(ADDRESS_STREET, STREET); addressMap.put(ADDRESS_NUM, NUM); employeeMap.put(EMPLOYEE_ADDRESS, addressMap); context.setModel(employeeMap); helper.initContext(context); assertNotNull(context.getModel()); assertTrue(context.getModel() instanceof MapBindableProxy); MapBindableProxy model = (MapBindableProxy) context.getModel(); checkBindableProxy(model); checkModelPropertyValue(model, EMPLOYEE_NAME, NAME); checkModelPropertyValue(model, EMPLOYEE_SURNAME, SURNAME); checkModelPropertyValue(model, EMPLOYEE_AGE_BINDING, AGE); checkModelPropertyValue(model, EMPLOYEE_BIRTHDAY, BIRTHDAY); checkModelPropertyValue(model, EMPLOYEE_MARRIED, MARRIED); assertNotNull(model.get(EMPLOYEE_ADDRESS)); assertTrue(model.get(EMPLOYEE_ADDRESS) instanceof MapBindableProxy); MapBindableProxy addressModel = (MapBindableProxy) model.get(EMPLOYEE_ADDRESS); checkModelPropertyValue(addressModel, ADDRESS_STREET, STREET); checkModelPropertyValue(addressModel, ADDRESS_NUM, NUM); }
|
DirectionalLine extends AbstractDirectionalMultiPointShape<DirectionalLine> { @Override @SuppressWarnings("unused") public Point2D adjustPoint(final double x, final double y, final double deltaX, final double deltaY) { return new Point2D(x, y); } DirectionalLine(final double x1,
final double y1,
final double x2,
final double y2); DirectionalLine(final Point2D start,
final Point2D end); DirectionalLine(final Point2DArray points); DirectionalLine setControlPoints(final Point2DArray points); Point2DArray getControlPoints(); @Override DirectionalLine refresh(); @Override @SuppressWarnings("unused") Point2D adjustPoint(final double x,
final double y,
final double deltaX,
final double deltaY); @Override boolean isControlPointShape(); @Override boolean parse(final Attributes attr); @Override Point2D getTailOffsetPoint(); @Override Point2D getHeadOffsetPoint(); @Override DirectionalLine setPoint2DArray(final Point2DArray points); @Override Point2DArray getPoint2DArray(); @Override List<Attribute> getBoundingBoxAttributes(); @Override BoundingBox getBoundingBox(); }
|
@Test public void testAdjustPoint() { final double X = 100d; final double Y = 200d; final double DELTA_X = 5d; final double DELTA_Y = 10d; final Point2D p = tested.adjustPoint(X, Y, DELTA_X, DELTA_Y); assertEquals(X, p.getX(), 0d); assertEquals(Y, p.getY(), 0d); }
|
BeanPropertiesProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { HashMap<String, String> values = new HashMap<>(); if (context instanceof FormEditorRenderingContext && context.getParentContext() != null) { if (context.getParentContext().getModel() instanceof MultipleSubFormFieldDefinition) { FormEditorRenderingContext editorContext = (FormEditorRenderingContext) context; if (context.getParentContext() != null) { MultipleSubFormFieldDefinition subForm = (MultipleSubFormFieldDefinition) context.getParentContext().getModel(); Path path = editorContext.getFormPath(); String typeName = subForm.getStandaloneClassName(); final TableColumnMeta currentMeta = (TableColumnMeta) context.getModel(); Set<String> unavailableProperties = subForm.getColumnMetas().stream().map(TableColumnMeta::getProperty).collect(Collectors.toSet()); if (currentMeta != null && !StringUtils.isEmpty(currentMeta.getProperty())) { unavailableProperties.remove(currentMeta.getProperty()); } modelFinderService.getModel(typeName, path).getProperties().stream() .filter(property -> !unavailableProperties.contains(property.getName())) .forEachOrdered(property -> values.put(property.getName(), property.getName())); } } } return new SelectorData(values,null); } @Inject BeanPropertiesProvider(ModelFinderService modelFinderService); @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); }
|
@Test public void testWithoutParentContext() { SelectorData data = provider.getSelectorData(context); assertNotNull(data); assertNotNull(data.getValues()); assertTrue(data.getValues().isEmpty()); assertNull(data.getSelectedValue()); }
|
DataObjectFormModelHandler extends AbstractFormModelHandler<DataObjectFormModel> { @Override public void checkSourceModel() throws SourceFormModelNotFoundException { checkInitialized(); if (updatedFormModel == null) { String[] params = new String[]{formModel.getClassName()}; throw new SourceFormModelNotFoundException(SHORT_KEY, params, FULL_KEY, params, DATA_OBJECT_KEY, formModel); } } @Inject DataObjectFormModelHandler(final KieModuleService moduleService,
final ModuleClassLoaderHelper classLoaderHelper,
final ModelFinderService finderService,
final FieldManager fieldManager); @Override Class<DataObjectFormModel> getModelType(); @Override void checkSourceModel(); @Override FormModelHandler<DataObjectFormModel> newInstance(); }
|
@Test public void testCheckModelSource() { Assertions.assertThatCode(() -> handler.checkSourceModel()) .doesNotThrowAnyException(); createModel("com.example.model.WrongModel"); handler.init(formModel, currentModulePath); Assertions.assertThatThrownBy(() -> handler.checkSourceModel()) .isInstanceOf(SourceFormModelNotFoundException.class); }
|
BPMFinderServiceImpl implements BPMFinderService { @Override public List<JBPMProcessModel> getAvailableProcessModels(final Path path) { return findModels(path, definitions -> true) .collect(Collectors.toList()); } @Inject BPMFinderServiceImpl(@Named("ioStrategy") IOService ioService,
KieModuleService moduleService,
BPMNFormModelGenerator bpmnFormModelGenerator); @Override List<JBPMProcessModel> getAvailableProcessModels(final Path path); @Override JBPMProcessModel getModelForProcess(final String processId, final Path path); }
|
@Test public void testFindAllProcessFormModels() { List<JBPMProcessModel> models = bpmFinderService.getAvailableProcessModels(currentModulePath); assertNotNull(models); assertEquals(EXPECTED_PROCESSES, models.size()); models.forEach(model -> { assertNotNull(model.getProcessFormModel()); if (model.getProcessFormModel().getProcessId().equals(PROCESS_WITH_ALL_VARIABLES_ID)) { assertEquals(PROCESS_WITH_ALL_VARIABLES_TASKS, model.getTaskFormModels().size()); } else if (model.getProcessFormModel().getProcessId().equals(PROCESS_WITHOUT_VARIABLES_ID)) { assertEquals(PROCESS_WITHOUT_VARIABLES_TASKS, model.getTaskFormModels().size()); } else if (model.getProcessFormModel().getProcessId().equals(PROCESS_WITH_SHARED_FORMS_ID)) { assertEquals(PROCESS_WITH_SHARED_FORMS_TASKS, model.getTaskFormModels().size()); } else if (model.getProcessFormModel().getProcessId().equals(PROCESS_WITH_SHARED_FORMS_WRONG_MAPPINGS_ID)) { assertEquals(PROCESS_WITH_SHARED_FORMS_WRONG_MAPPINGS_TASKS, model.getTaskFormModels().size()); } else if (model.getProcessFormModel().getProcessId().equals(PROCESS_WITH_WRONG_TYPES)) { assertEquals(PROCESS_WITH_WRONG_TYPES_TASKS, model.getTaskFormModels().size()); } else { fail("Unexpected process: " + model.getProcessFormModel().getProcessId()); } }); }
|
UploadedDocumentServiceImpl implements UploadedDocumentService,
Serializable { @Override public DocumentUploadResponse uploadContent(final DocumentUploadChunk chunk) { try { DocumentUploadSession session = getSession(chunk); if (session.isComplete()) { return merge(session); } else { return new DocumentUploadResponse(DocumentUploadResponse.DocumentUploadState.UPLOADING, true); } } catch (Exception ex) { logger.warn("Cannot upload chunk {}: {}", chunk.getDocumentName(), ex); return new DocumentUploadResponse(DocumentUploadResponse.DocumentUploadState.FINISH, false); } } @Inject UploadedDocumentServiceImpl(UploadedDocumentStorage storage); @Override DocumentUploadResponse uploadContent(final DocumentUploadChunk chunk); @Override void removeContent(String id); @PreDestroy void clear(); }
|
@Test public void testSuccessfullyUpload() { DocumentUploadChunk chunk1 = new DocumentUploadChunk(DOC_ID, DOC_NAME, 0, 3, Base64.getEncoder().encodeToString(PART_1.getBytes())); DocumentUploadResponse response = uploadedDocumentService.uploadContent(chunk1); validateResponse(response, DocumentUploadResponse.DocumentUploadState.UPLOADING, true); DocumentUploadSession session = uploadedDocumentService.getUploadSessions().get(DOC_ID); Assertions.assertThat(session).isNotNull(); Assertions.assertThat(session.getChunks()) .isNotNull() .hasSize(1) .containsExactly(chunk1); checkParts(1); DocumentUploadChunk chunk2 = new DocumentUploadChunk(DOC_ID, DOC_NAME, 1, 3, Base64.getEncoder().encodeToString(PART_2.getBytes())); response = uploadedDocumentService.uploadContent(chunk2); validateResponse(response, DocumentUploadResponse.DocumentUploadState.UPLOADING, true); session = uploadedDocumentService.getUploadSessions().get(DOC_ID); Assertions.assertThat(session).isNotNull(); Assertions.assertThat(session.getChunks()) .isNotNull() .hasSize(2) .containsExactly(chunk1, chunk2); checkParts(2); DocumentUploadChunk chunk3 = new DocumentUploadChunk(DOC_ID, DOC_NAME, 3, 3, Base64.getEncoder().encodeToString(PART_3.getBytes())); response = uploadedDocumentService.uploadContent(chunk3); validateResponse(response, DocumentUploadResponse.DocumentUploadState.FINISH, true); session = uploadedDocumentService.getUploadSessions().get(DOC_ID); Assertions.assertThat(session).isNull(); File file = storage.getRootFolder().resolve(DOC_ID).resolve(DOC_NAME).toFile(); Assertions.assertThat(file) .isNotNull() .exists(); String content = new String(storage.getContent(DOC_ID)); Assertions.assertThat(content) .isNotNull() .isEqualTo(PART_1 + PART_2 + PART_3); }
@Test public void testUploadWithError() throws Exception { doThrow(new RuntimeException("Exception")).when(storage).uploadContentChunk(any()); DocumentUploadChunk chunk = new DocumentUploadChunk(DOC_ID, DOC_NAME, 0, 3, Base64.getEncoder().encodeToString(PART_1.getBytes())); DocumentUploadResponse response = uploadedDocumentService.uploadContent(chunk); validateResponse(response, DocumentUploadResponse.DocumentUploadState.FINISH, false); }
|
UploadedDocumentServiceImpl implements UploadedDocumentService,
Serializable { @Override public void removeContent(String id) { DocumentUploadSession session = uploadSessions.remove(id); if (session != null) { session.setState(DocumentUploadSession.State.ABORTED); storage.removeContent(id); } else { storage.removeContent(id); } } @Inject UploadedDocumentServiceImpl(UploadedDocumentStorage storage); @Override DocumentUploadResponse uploadContent(final DocumentUploadChunk chunk); @Override void removeContent(String id); @PreDestroy void clear(); }
|
@Test public void testSuccesfullyUploadAndCleanup() { testSuccessfullyUpload(); uploadedDocumentService.removeContent(DOC_ID); File file = storage.getRootFolder().resolve(DOC_ID).resolve(DOC_NAME).toFile(); Assertions.assertThat(file) .isNotNull() .doesNotExist(); }
|
TaskFormModelHandler extends AbstractJBPMFormModelHandler<TaskFormModel> { @Override public void checkSourceModel() throws SourceFormModelNotFoundException { JBPMProcessModel processModel = bpmFinderService.getModelForProcess(formModel.getProcessId(), path); if (processModel != null) { Optional<TaskFormModel> optional = processModel.getTaskFormModels().stream() .filter(taskFormModel -> taskFormModel.getFormName().equals(formModel.getFormName())) .findAny(); if (!optional.isPresent()) { String[] params = new String[]{formModel.getTaskName(), formModel.getProcessId()}; throw new SourceFormModelNotFoundException(JBPMFormsIntegrationBackendConstants.MISSING_TASK_SHORT_KEY, params, JBPMFormsIntegrationBackendConstants.MISSING_TASK_FULL_KEY, params, JBPMFormsIntegrationBackendConstants.PROCESS_KEY, formModel); } } else { String[] params = new String[]{formModel.getProcessId()}; throw new SourceFormModelNotFoundException(JBPMFormsIntegrationBackendConstants.MISSING_PROCESS_SHORT_KEY, params, JBPMFormsIntegrationBackendConstants.MISSING_PROCESS_FULL_KEY, params, JBPMFormsIntegrationBackendConstants.PROCESS_KEY, formModel); } } @Inject TaskFormModelHandler(KieModuleService projectService,
ModuleClassLoaderHelper classLoaderHelper,
FieldManager fieldManager,
BPMFinderService bpmFinderService); @Override Class<TaskFormModel> getModelType(); @Override void checkSourceModel(); @Override FormModelHandler<TaskFormModel> newInstance(); }
|
@Test public void testCheckModelSource() { when(finderService.getModelForProcess(any(), any())).thenReturn(getFullProcessModel()); Assertions.assertThatCode(() -> handler.checkSourceModel()) .doesNotThrowAnyException(); when(finderService.getModelForProcess(any(), any())).thenReturn(null); Assertions.assertThatThrownBy(() -> handler.checkSourceModel()) .isInstanceOf(SourceFormModelNotFoundException.class); when(finderService.getModelForProcess(any(), any())).thenReturn(getBaseProcessModel()); Assertions.assertThatThrownBy(() -> handler.checkSourceModel()) .isInstanceOf(SourceFormModelNotFoundException.class); }
|
BPMNFormModelGeneratorImpl implements BPMNFormModelGenerator { @Override public TaskFormModel generateTaskFormModel(Definitions source, String taskId, Path path) { Process process = getProcess(source); if (process != null) { ProcessTaskFormsGenerationResult generationResult = readUserTaskFormVariables(process); Optional<TaskFormVariables> resultTaskFormVariables = Optional.ofNullable(generationResult.getTaskFormVariablesByTaskId(taskId)); if (resultTaskFormVariables.isPresent()) { TaskFormVariables formVariables = resultTaskFormVariables.get(); if (!formVariables.isValid()) { throw new IllegalStateException(generateErrorMessage(formVariables)); } final ClassLoader projectClassLoader = projectClassLoaderHelper.getModuleClassLoader(moduleService.resolveModule(path)); return formVariables.toFormModel(variable -> createModelProperty(variable, projectClassLoader)); } } return null; } @Inject BPMNFormModelGeneratorImpl(KieModuleService moduleService,
ModuleClassLoaderHelper projectClassLoaderHelper); @Override BusinessProcessFormModel generateProcessFormModel(Definitions source,
Path path); @Override List<TaskFormModel> generateTaskFormModels(Definitions source,
Path path); @Override TaskFormModel generateTaskFormModel(Definitions source,
String taskId,
Path path); @Override Process getProcess(Definitions source); }
|
@Test public void testCorrectTaskFormModelIsGeneratedForTaskWithoutAnyInputsOrOutputsInSwimlane() { final String TASK_ID = "_23BBA464-615A-405F-8C3B-4F643BE522D6", TASK_NAME = "emptyTask"; TaskFormModel taskFormModel = generator.generateTaskFormModel(processWithAllVariablesDefinitions, TASK_ID, path); assertTaskFormModelIsCorrect(taskFormModel, PROCESS_WITH_ALL_VARIABLES_ID, TASK_NAME); assertTrue(taskFormModel.getProperties().isEmpty()); }
@Test public void testCorrectTaskFormModelIsGeneratedForTaskWithDifferentInputsAndOutputsInAdHocSubprocess() { final String TASK_ID = "_D3B8EE8F-5402-408D-815D-FFE1BAD943D9", TASK_NAME = "taskWithDifferentInputsAndOutputs"; final Map<String, String> EXPECTED_TASK_VARIABLES = new HashMap<String, String>() {{ putAll(EXPECTED_INPUT_VARIABLES); putAll(EXPECTED_OUTPUT_VARIABLES); }}; TaskFormModel taskFormModel = generator.generateTaskFormModel(processWithAllVariablesDefinitions, TASK_ID, path); assertTaskFormModelIsCorrect(taskFormModel, PROCESS_WITH_ALL_VARIABLES_ID, TASK_NAME); assertJBPMVariablesAreCorrect(taskFormModel, EXPECTED_TASK_VARIABLES); }
@Test public void testCorrectTaskFormModelIsGeneratedForTaskWithTheInputsAndOutputsBoundToTheSameNamesInSwimlane() { final String TASK_ID = "_9903B013-C42D-486B-A41D-2DEBC60911E3", TASK_NAME = "taskWithTheSameInputsAndOutputs"; final Map<String, String> EXPECTED_TASK_VARIABLES = new HashMap<String, String>() {{ put("_string_", String.class.getName()); put("_integer_", Integer.class.getName()); put("_boolean_", Boolean.class.getName()); put("_float_", Float.class.getName()); put("_object_", Object.class.getName()); put("_dataObject_", DATA_OBJECT_TYPE); put("_customType_", CUSTOM_TYPE); put("_list_", Object.class.getName()); }}; TaskFormModel taskFormModel = generator.generateTaskFormModel(processWithAllVariablesDefinitions, TASK_ID, path); assertTaskFormModelIsCorrect(taskFormModel, PROCESS_WITH_ALL_VARIABLES_ID, TASK_NAME); assertJBPMVariablesAreCorrect(taskFormModel, EXPECTED_TASK_VARIABLES); }
@Test public void testCorrectTaskFormModelIsGeneratedForTaskThatContainsOnlyInputs() { final String TASK_ID = "_9F3A7665-E7EF-4DC2-94F1-F9D20A38547E", TASK_NAME = "taskOnlyWithInputs"; TaskFormModel taskFormModel = generator.generateTaskFormModel(processWithAllVariablesDefinitions, TASK_ID, path); assertTaskFormModelIsCorrect(taskFormModel, PROCESS_WITH_ALL_VARIABLES_ID, TASK_NAME); assertJBPMVariablesAreCorrect(taskFormModel, EXPECTED_INPUT_VARIABLES); }
@Test public void testCorrectTaskFormModelIsGeneratedForTaskThatContainsOnlyOutputsInEmbeddedSubprocess() { final String TASK_ID = "_9E9EAE16-F9F4-49D0-854D-0D2C8CB9382F", TASK_NAME = "taskOnlyWithOutputs"; TaskFormModel taskFormModel = generator.generateTaskFormModel(processWithAllVariablesDefinitions, TASK_ID, path); assertTaskFormModelIsCorrect(taskFormModel, PROCESS_WITH_ALL_VARIABLES_ID, TASK_NAME); assertJBPMVariablesAreCorrect(taskFormModel, EXPECTED_OUTPUT_VARIABLES); }
@Test public void testGenerateTaskFormModelForTaskWithSharedForm() { final String[] TASK_IDS = new String[]{"_77BDDEC9-0D5E-4C46-8AD6-1B528836A22B", "_C976E341-8E35-42C7-B878-67049CE63E5F", "_27F23135-87E9-47C5-9B97-DA793699E8CF"}; final String TASK_NAME = "task"; TaskFormModel[] generatedModels = new TaskFormModel[TASK_IDS.length]; for (int i = 0; i < TASK_IDS.length; i++) { generatedModels[i] = generator.generateTaskFormModel(processWithSharedForms, TASK_IDS[i], path); assertNotNull(generatedModels[i]); assertTaskFormModelIsCorrect(generatedModels[i], PROCESS_WITH_SHARED_FORMS_ID, TASK_NAME); checkExpectedMergedFormVariables(generatedModels[i]); } }
@Test public void testGenerateTaskFormModelForTaskWithSharedFormWithWrongMappings() { final String[] TASK_IDS = new String[]{"_77BDDEC9-0D5E-4C46-8AD6-1B528836A22B", "_C976E341-8E35-42C7-B878-67049CE63E5F", "_27F23135-87E9-47C5-9B97-DA793699E8CF"}; int count = 0; for (int i = 0; i < TASK_IDS.length; i++) { try { generator.generateTaskFormModel(processWithSharedFormsWrongMappings, TASK_IDS[i], path); fail("We shouldn't be here, the form generation should break!"); } catch (Exception ex) { count++; } } assertEquals(TASK_IDS.length, count); }
|
DMNSVGShapeDefImpl implements DMNSVGShapeDef<DMNViewDefinition, DMNSVGViewFactory> { @Override public SVGShapeView<?> newViewInstance(final DMNSVGViewFactory factory, final DMNViewDefinition bean) { final double width = bean.getDimensionsSet().getWidth().getValue(); final double height = bean.getDimensionsSet().getHeight().getValue(); return VIEW_RESOURCES .getResource(factory, bean) .build(width, height, true); } @Override Class<DMNSVGViewFactory> getViewFactoryType(); @Override SVGShapeView<?> newViewInstance(final DMNSVGViewFactory factory,
final DMNViewDefinition bean); @Override Glyph getGlyph(final Class<? extends DMNViewDefinition> type,
final String defId); @Override Glyph getGlyph(final Class<? extends DMNViewDefinition> type,
final Class<? extends ShapeFactory.GlyphConsumer> consumer,
final String defId); static final SVGShapeViewResources<DMNDefinition, DMNSVGViewFactory> VIEW_RESOURCES; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_TOOLBOX; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_PALETTE; }
|
@Test public void testNewViewInstance() { final BusinessKnowledgeModel businessKnowledgeModel = new BusinessKnowledgeModel(); shapeDef.newViewInstance(viewFactory, businessKnowledgeModel); verify(viewFactory).businessKnowledgeModel(); verify(viewResource).build(businessKnowledgeModel.getDimensionsSet().getWidth().getValue(), businessKnowledgeModel.getDimensionsSet().getHeight().getValue(), true); reset(viewResource); final Decision decision = new Decision(); shapeDef.newViewInstance(viewFactory, decision); verify(viewFactory).decision(); verify(viewResource).build(decision.getDimensionsSet().getWidth().getValue(), decision.getDimensionsSet().getHeight().getValue(), true); reset(viewResource); shapeDef.newViewInstance(viewFactory, new InputData()); verify(viewFactory).inputData(); verify(viewResource).build(businessKnowledgeModel.getDimensionsSet().getWidth().getValue(), businessKnowledgeModel.getDimensionsSet().getHeight().getValue(), true); reset(viewResource); final KnowledgeSource knowledgeSource = new KnowledgeSource(); shapeDef.newViewInstance(viewFactory, knowledgeSource); verify(viewFactory).knowledgeSource(); verify(viewResource).build(knowledgeSource.getDimensionsSet().getWidth().getValue(), knowledgeSource.getDimensionsSet().getHeight().getValue(), true); reset(viewResource); final TextAnnotation textAnnotation = new TextAnnotation(); shapeDef.newViewInstance(viewFactory, textAnnotation); verify(viewFactory).textAnnotation(); verify(viewResource).build(textAnnotation.getDimensionsSet().getWidth().getValue(), textAnnotation.getDimensionsSet().getHeight().getValue(), true); }
|
BPMNFormModelGeneratorImpl implements BPMNFormModelGenerator { @Override public List<TaskFormModel> generateTaskFormModels(Definitions source, Path path) { Process process = getProcess(source); final ClassLoader projectClassLoader = projectClassLoaderHelper.getModuleClassLoader(moduleService.resolveModule(path)); if (process != null) { ProcessTaskFormsGenerationResult result = readUserTaskFormVariables(process); return result.getAllTaskFormVariables().stream().filter(taskFormVariables -> { if (!taskFormVariables.isValid()) { logger.warn(generateErrorMessage(taskFormVariables)); return false; } return true; }).map(taskFormVariables -> taskFormVariables.toFormModel(variable -> createModelProperty(variable, projectClassLoader))) .collect(Collectors.toList()); } return Collections.emptyList(); } @Inject BPMNFormModelGeneratorImpl(KieModuleService moduleService,
ModuleClassLoaderHelper projectClassLoaderHelper); @Override BusinessProcessFormModel generateProcessFormModel(Definitions source,
Path path); @Override List<TaskFormModel> generateTaskFormModels(Definitions source,
Path path); @Override TaskFormModel generateTaskFormModel(Definitions source,
String taskId,
Path path); @Override Process getProcess(Definitions source); }
|
@Test public void testGenerateAllTaskFormModelForTasksWithSharedForm() { final String TASK_NAME = "task"; final int EXPECTED_MODELS = 2; List<TaskFormModel> generatedModels = generator.generateTaskFormModels(processWithSharedForms, path); assertNotNull(generatedModels); assertEquals(EXPECTED_MODELS, generatedModels.size()); for (TaskFormModel formModel : generatedModels) { assertNotNull(formModel); assertEquals(PROCESS_WITH_SHARED_FORMS_ID, formModel.getProcessId()); assertNotNull(formModel.getProperties()); assertFalse(formModel.getProperties().isEmpty()); if (formModel.getFormName().equals(TASK_NAME + BPMNVariableUtils.TASK_FORM_SUFFIX)) { checkExpectedMergedFormVariables(formModel); } } }
@Test public void testGenerateAllTaskFormModelForTasksWithSharedFormWithWrongMappings() { final String TASK_NAME = "task"; final int EXPECTED_MODELS = 1; List<TaskFormModel> generatedModels = generator.generateTaskFormModels(processWithSharedFormsWrongMappings, path); assertNotNull(generatedModels); assertEquals(EXPECTED_MODELS, generatedModels.size()); for (TaskFormModel formModel : generatedModels) { assertNotNull(formModel); assertEquals(PROCESS_WITH_SHARED_FORMS_WRONG_MAPPINGS_ID, formModel.getProcessId()); assertNotNull(formModel.getProperties()); assertFalse(formModel.getProperties().isEmpty()); assertNotEquals(TASK_NAME + BPMNVariableUtils.TASK_FORM_SUFFIX, formModel.getFormName()); } }
|
BusinessProcessFormModelHandler extends AbstractJBPMFormModelHandler<BusinessProcessFormModel> { @Override public void checkSourceModel() throws SourceFormModelNotFoundException { if (getSourceModel() == null) { String[] params = new String[]{formModel.getProcessId()}; throw new SourceFormModelNotFoundException(JBPMFormsIntegrationBackendConstants.MISSING_PROCESS_SHORT_KEY, params, JBPMFormsIntegrationBackendConstants.MISSING_PROCESS_FULL_KEY, params, JBPMFormsIntegrationBackendConstants.PROCESS_KEY, formModel); } } @Inject BusinessProcessFormModelHandler(KieModuleService projectService,
ModuleClassLoaderHelper classLoaderHelper,
FieldManager fieldManager,
BPMFinderService bpmFinderService); @Override Class<BusinessProcessFormModel> getModelType(); @Override FormModelHandler<BusinessProcessFormModel> newInstance(); @Override void checkSourceModel(); }
|
@Test public void testCheckModelSource() { when(finderService.getModelForProcess(any(), any())).thenReturn(getProcessModel()); Assertions.assertThatCode(() -> handler.checkSourceModel()) .doesNotThrowAnyException(); when(finderService.getModelForProcess(any(), any())).thenReturn(null); Assertions.assertThatThrownBy(() -> handler.checkSourceModel()) .isInstanceOf(SourceFormModelNotFoundException.class); }
|
DocumentFieldValueMarshaller extends AbstractFieldValueMarshaller<Document, DocumentData, DocumentFieldDefinition> { @Override public DocumentData toFlatValue() { if (originalValue == null) { return null; } String templateId = (String) context.getAttributes().get(SERVER_TEMPLATE_ID); return fromDocument(originalValue, templateId); } @Inject DocumentFieldValueMarshaller(UploadedDocumentStorage documentStorage); @Override Class<DocumentFieldDefinition> getSupportedField(); @Override Supplier<FieldValueMarshaller<Document, DocumentData, DocumentFieldDefinition>> newInstanceSupplier(); @Override DocumentData toFlatValue(); @Override Document toRawValue(DocumentData documentData); static final String SERVER_TEMPLATE_ID; }
|
@Test public void testNull2FlatValue() { marshaller.init(null, field, form, context); DocumentData documentData = marshaller.toFlatValue(); assertNull("DocumentData must be null!", documentData); }
@Test public void testDocument2FlatValueEmptyLinkPattern() { Document doc = spy(new DocumentImpl(DOCUMENT_ID, "docName", 1024, new Date())); marshaller.init(doc, field, form, context); DocumentData documentData = marshaller.toFlatValue(); verify(doc).getLink(); assertNotNull(documentData); assertEquals(doc.getName(), documentData.getFileName()); assertEquals(doc.getSize(), documentData.getSize()); assertEquals("", documentData.getLink()); }
@Test public void testDocument2FlatValue() { Document doc = spy(new DocumentImpl(DOCUMENT_ID, "docName", 1024, new Date())); Map result = new HashMap(); result.put(DocumentFieldValueMarshaller.SERVER_TEMPLATE_ID, SERVER_TEMPLATE_ID); when(context.getAttributes()).thenReturn(result); marshaller.init(doc, field, form, context); DocumentData documentData = marshaller.toFlatValue(); verify(doc, never()).getLink(); assertNotNull(documentData); assertEquals(doc.getName(), documentData.getFileName()); assertEquals(doc.getSize(), documentData.getSize()); assertEquals(EXPECTED_DOWNLOAD_LINK, documentData.getLink()); }
|
DMNSVGShapeDefImpl implements DMNSVGShapeDef<DMNViewDefinition, DMNSVGViewFactory> { @Override public Glyph getGlyph(final Class<? extends DMNViewDefinition> type, final String defId) { return GLYPHS_TOOLBOX.computeIfAbsent(type, (t) -> ShapeGlyph.create()); } @Override Class<DMNSVGViewFactory> getViewFactoryType(); @Override SVGShapeView<?> newViewInstance(final DMNSVGViewFactory factory,
final DMNViewDefinition bean); @Override Glyph getGlyph(final Class<? extends DMNViewDefinition> type,
final String defId); @Override Glyph getGlyph(final Class<? extends DMNViewDefinition> type,
final Class<? extends ShapeFactory.GlyphConsumer> consumer,
final String defId); static final SVGShapeViewResources<DMNDefinition, DMNSVGViewFactory> VIEW_RESOURCES; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_TOOLBOX; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_PALETTE; }
|
@Test public void testGetToolboxGlyph() { assertEquals(DMNSVGGlyphFactory.BUSINESS_KNOWLEDGE_MODEL_TOOLBOX, shapeDef.getGlyph(BusinessKnowledgeModel.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.DECISION_TOOLBOX, shapeDef.getGlyph(Decision.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.INPUT_DATA_TOOLBOX, shapeDef.getGlyph(InputData.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.KNOWLEDGE_SOURCE_TOOLBOX, shapeDef.getGlyph(KnowledgeSource.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.TEXT_ANNOTATION_TOOLBOX, shapeDef.getGlyph(TextAnnotation.class, DEFINITION_ID)); assertTrue(shapeDef.getGlyph(DMNViewDefinition.class, DEFINITION_ID) instanceof ShapeGlyph); }
@Test public void testGetPaletteGlyphWithConsumer() { assertEquals(DMNSVGGlyphFactory.BUSINESS_KNOWLEDGE_MODEL_PALETTE, shapeDef.getGlyph(BusinessKnowledgeModel.class, PaletteGlyphConsumer.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.DECISION_PALETTE, shapeDef.getGlyph(Decision.class, PaletteGlyphConsumer.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.DECISION_SERVICE_PALETTE, shapeDef.getGlyph(DecisionService.class, PaletteGlyphConsumer.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.INPUT_DATA_PALETTE, shapeDef.getGlyph(InputData.class, PaletteGlyphConsumer.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.KNOWLEDGE_SOURCE_PALETTE, shapeDef.getGlyph(KnowledgeSource.class, PaletteGlyphConsumer.class, DEFINITION_ID)); assertEquals(DMNSVGGlyphFactory.TEXT_ANNOTATION_PALETTE, shapeDef.getGlyph(TextAnnotation.class, PaletteGlyphConsumer.class, DEFINITION_ID)); assertEquals(true, shapeDef.getGlyph(DMNViewDefinition.class, PaletteGlyphConsumer.class, DEFINITION_ID) instanceof ShapeGlyph); }
|
DocumentFieldValueMarshaller extends AbstractFieldValueMarshaller<Document, DocumentData, DocumentFieldDefinition> { @Override public Document toRawValue(DocumentData documentData) { if (documentData == null) { return null; } if (documentData.getStatus().equals(DocumentStatus.STORED)) { return originalValue; } return toDocument(documentData, documentStorage); } @Inject DocumentFieldValueMarshaller(UploadedDocumentStorage documentStorage); @Override Class<DocumentFieldDefinition> getSupportedField(); @Override Supplier<FieldValueMarshaller<Document, DocumentData, DocumentFieldDefinition>> newInstanceSupplier(); @Override DocumentData toFlatValue(); @Override Document toRawValue(DocumentData documentData); static final String SERVER_TEMPLATE_ID; }
|
@Test public void testNullFlatValue2Document() { marshaller.init(null, field, form, context); Document doc = marshaller.toRawValue(null); assertNull("Document must be null!", doc); }
@Test public void testNewFlatValue2Document() { marshaller.init(null, field, form, context); DocumentData data = new DocumentData(DOCUMENT_ID, 1024, null); data.setContentId("content"); Document doc = marshaller.toRawValue(data); verify(documentStorage).getContent(anyString()); verify(documentStorage).removeContent(anyString()); assertNotNull("Document cannot be null!", doc); assertEquals("Names are not equal", data.getFileName(), doc.getName()); assertEquals("Sizes are not equal", data.getSize(), doc.getSize()); }
@Test public void testExistingFlatValue2Document() { Document doc = new DocumentImpl(DOCUMENT_ID, "docName", 1024, new Date(), "aLink"); marshaller.init(doc, field, form, context); DocumentData data = new DocumentData(doc.getName(), doc.getSize(), doc.getLink()); data.setStatus(DocumentStatus.STORED); Document rawDoc = marshaller.toRawValue(data); assertEquals("Documents must be equal!", doc, rawDoc); verify(documentStorage, never()).getContent(anyString()); verify(documentStorage, never()).removeContent(anyString()); }
|
DocumentUpload implements DocumentUploadView.Presenter,
IsWidget { public void setMaxDocuments(int maxDocuments) { this.maxDocuments = maxDocuments; if (maxDocuments > 0) { view.setMaxDocuments(translationService.format(Constants.DocumentUploadViewImplMaxDocuments, maxDocuments)); } else { view.setMaxDocuments(""); } } @Inject DocumentUpload(final DocumentUploadManager uploader, final DocumentUploadView view, final ManagedInstance<DocumentPreview> instance, final TranslationService translationService); @PostConstruct void init(); @Override Collection<DocumentPreview> getCurrentPreviews(); @Override void doUpload(final Document document, File file); @Override List<DocumentData> getValue(); @Override void setValue(List<DocumentData> value); void setEnabled(boolean enabled); void setMaxDocuments(int maxDocuments); @Override void setValue(List<DocumentData> value, boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(ValueChangeHandler<List<DocumentData>> valueChangeHandler); @Override void fireEvent(GwtEvent<?> event); @Override Widget asWidget(); }
|
@Test public void testSetMaxElements() { documentUpload.setMaxDocuments(5); verify(translationService).format(eq(Constants.DocumentUploadViewImplMaxDocuments), eq(5)); verify(view).setMaxDocuments(anyString()); documentUpload.setMaxDocuments(0); verify(view).setMaxDocuments(eq("")); }
|
DocumentPreview implements DocumentPreviewView.Presenter,
IsElement { public void setStateHandler(DocumentPreviewStateActionsHandler handler) { this.actionsHandler = handler; actionsHandler.setStateChangeListener(this::setState); initState(); } @Inject DocumentPreview(DocumentPreviewView view, TranslationService translationService); void init(DocumentData documentData); @Override String getDocumentLink(); @Override String getDocumentName(); void setState(DocumentPreviewState state); DocumentData getDocumentData(); @Override HTMLElement getElement(); void setEnabled(boolean enabled); void setStateHandler(DocumentPreviewStateActionsHandler handler); }
|
@Test public void testSetStateHandler() { testInitNew(); preview.setStateHandler(handler); verify(handler).getCurrentStateActions(); verify(handler).setStateChangeListener(any()); ArgumentCaptor<Collection> actionsCaptor = ArgumentCaptor.forClass(Collection.class); verify(view).setState(any(), actionsCaptor.capture()); Assertions.assertThat(actionsCaptor.getValue()) .isNotNull() .hasSize(1); }
|
DocumentPreview implements DocumentPreviewView.Presenter,
IsElement { public void setState(DocumentPreviewState state) { this.state = state; initState(); } @Inject DocumentPreview(DocumentPreviewView view, TranslationService translationService); void init(DocumentData documentData); @Override String getDocumentLink(); @Override String getDocumentName(); void setState(DocumentPreviewState state); DocumentData getDocumentData(); @Override HTMLElement getElement(); void setEnabled(boolean enabled); void setStateHandler(DocumentPreviewStateActionsHandler handler); }
|
@Test public void testNotifyStateChange() { testSetStateHandler(); preview.setState(DocumentPreviewState.UPLOADED); verify(handler, times(2)).getCurrentStateActions(); verify(view, times(2)).setState(any(), anyList()); }
@Test public void setSetStateDisabled() { testDisable(); preview.setState(DocumentPreviewState.STORED); verify(handler, times(1)).getCurrentStateActions(); verify(view, times(2)).setState(any(), anyList()); }
|
StringSelectorOption implements SelectorOption<String> { public void setValue(String value) { this.value = value; } StringSelectorOption(); StringSelectorOption(@MapsTo("value") String value,
@MapsTo("text") String text); @Override String getValue(); void setValue(String value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetValue() { StringSelectorOption opt = new StringSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); }
|
StringSelectorOption implements SelectorOption<String> { public void setText(String text) { this.text = text; } StringSelectorOption(); StringSelectorOption(@MapsTo("value") String value,
@MapsTo("text") String text); @Override String getValue(); void setValue(String value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetText() { StringSelectorOption opt = new StringSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); }
|
IntegerSelectorOption implements SelectorOption<Long> { public void setValue(Long value) { this.value = value; } IntegerSelectorOption(); IntegerSelectorOption(@MapsTo("value") Long value,
@MapsTo("text") String text); @Override Long getValue(); void setValue(Long value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetValue() { IntegerSelectorOption opt = new IntegerSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); }
|
IntegerSelectorOption implements SelectorOption<Long> { public void setText(String text) { this.text = text; } IntegerSelectorOption(); IntegerSelectorOption(@MapsTo("value") Long value,
@MapsTo("text") String text); @Override Long getValue(); void setValue(Long value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetText() { IntegerSelectorOption opt = new IntegerSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); }
|
EnumSelectorOption implements SelectorOption<Enum> { public void setValue(Enum value) { this.value = value; } EnumSelectorOption(); EnumSelectorOption(Enum value); EnumSelectorOption(@MapsTo("value") Enum value,
@MapsTo("text") String text); @Override Enum getValue(); void setValue(Enum value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetValue() { EnumSelectorOption opt = new EnumSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); }
|
EnumSelectorOption implements SelectorOption<Enum> { public void setText(String text) { this.text = text; } EnumSelectorOption(); EnumSelectorOption(Enum value); EnumSelectorOption(@MapsTo("value") Enum value,
@MapsTo("text") String text); @Override Enum getValue(); void setValue(Enum value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetText() { IntegerSelectorOption opt = new IntegerSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); }
|
DefaultSelectorOption implements SelectorOption<Object> { public void setValue(T value) { this.value = value; } DefaultSelectorOption(); DefaultSelectorOption(@MapsTo("value") T value,
@MapsTo("text") String text); @Override Object getValue(); void setValue(T value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetValue() { DefaultSelectorOption opt = new DefaultSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); }
|
DefaultSelectorOption implements SelectorOption<Object> { public void setText(String text) { this.text = text; } DefaultSelectorOption(); DefaultSelectorOption(@MapsTo("value") T value,
@MapsTo("text") String text); @Override Object getValue(); void setValue(T value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetText() { DefaultSelectorOption opt = new DefaultSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override public ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo) { if (typeInfo.getType().equals(TypeKind.ENUM)) { return new EnumListBoxFieldDefinition(); } String className = typeInfo.getClassName(); if (Byte.class.getName().equals(className) || byte.class.getName().equals(className) || Short.class.getName().equals(className) || short.class.getName().equals(className) || Integer.class.getName().equals(className) || int.class.getName().equals(className) || Long.class.getName().equals(className) || long.class.getName().equals(className) || BigInteger.class.getName().equals(className)) { return new IntegerListBoxFieldDefinition(); } if (Float.class.getName().equals(className) || float.class.getName().equals(className) || Double.class.getName().equals(className) || double.class.getName().equals(className) || BigDecimal.class.getName().equals(className)) { return new DecimalListBoxFieldDefinition(); } if (Character.class.getName().equals(className) || char.class.getName().equals(className)) { return new CharacterListBoxFieldDefinition(); } for (String type : getSupportedTypes()) { if (type.equals(typeInfo.getClassName())) { return new StringListBoxFieldDefinition(); } } return new EnumListBoxFieldDefinition(); } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testCreateFieldByType() { testCreateFieldByType(byte.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(Byte.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(short.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(Short.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(int.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(Integer.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(long.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(Long.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(BigInteger.class, IntegerListBoxFieldDefinition.class); testCreateFieldByType(float.class, DecimalListBoxFieldDefinition.class); testCreateFieldByType(Float.class, DecimalListBoxFieldDefinition.class); testCreateFieldByType(double.class, DecimalListBoxFieldDefinition.class); testCreateFieldByType(Double.class, DecimalListBoxFieldDefinition.class); testCreateFieldByType(BigDecimal.class, DecimalListBoxFieldDefinition.class); testCreateFieldByType(char.class, CharacterListBoxFieldDefinition.class); testCreateFieldByType(Character.class, CharacterListBoxFieldDefinition.class); testCreateFieldByType(String.class, StringListBoxFieldDefinition.class); when(typeInfo.getType()).thenReturn(TypeKind.ENUM); testCreateFieldByType(Enum.class, EnumListBoxFieldDefinition.class); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override protected void doRegisterFields() { registerPropertyType(String.class); registerPropertyType(Integer.class); registerPropertyType(int.class); registerPropertyType(Long.class); registerPropertyType(long.class); registerPropertyType(BigInteger.class); registerPropertyType(Double.class); registerPropertyType(double.class); registerPropertyType(Float.class); registerPropertyType(float.class); registerPropertyType(BigDecimal.class); registerPropertyType(Short.class); registerPropertyType(short.class); registerPropertyType(Byte.class); registerPropertyType(byte.class); registerPropertyType(Character.class); registerPropertyType(char.class); } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testDoRegisterFields() { provider.doRegisterFields(); Arrays.stream(SUPPORTED_TYPES).forEach(type -> { assertTrue(provider.supports(type)); }); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override public int getPriority() { return 7; } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testGetPriority() { assertEquals(7, provider.getPriority()); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override public String getFieldTypeName() { return ListBoxFieldType.NAME; } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testGetFieldTypeName() { assertEquals(ListBoxFieldType.NAME, provider.getFieldTypeName()); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override public Class<ListBoxFieldType> getFieldType() { return ListBoxFieldType.class; } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testGetFieldType() { assertEquals(ListBoxFieldType.class, provider.getFieldType()); }
|
DMNDecisionServiceSVGShapeDefImpl implements DMNDecisionServiceSVGShapeDef { @Override public SVGShapeView<?> newViewInstance(final DMNDecisionServiceSVGViewFactory factory, final DecisionService bean) { final double width = bean.getDimensionsSet().getWidth().getValue(); final double height = bean.getDimensionsSet().getHeight().getValue(); return VIEW_RESOURCES .getResource(factory, bean) .build(width, height, true); } @Override Class<DMNDecisionServiceSVGViewFactory> getViewFactoryType(); @Override SizeHandler<DecisionService, SVGShapeView> newSizeHandler(); @Override FontHandler<DecisionService, SVGShapeView> newFontHandler(); @Override SVGShapeView<?> newViewInstance(final DMNDecisionServiceSVGViewFactory factory,
final DecisionService bean); @Override Glyph getGlyph(final Class<? extends DecisionService> type,
final Class<? extends ShapeFactory.GlyphConsumer> consumer,
final String defId); static final SVGShapeViewResources<DMNDefinition, DMNDecisionServiceSVGViewFactory> VIEW_RESOURCES; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_PALETTE; }
|
@Test public void testNewViewInstance() { final DecisionService decisionService = new DecisionService(); shapeDef.newViewInstance(viewFactory, decisionService); verify(viewFactory).decisionService(); verify(viewResource).build(decisionService.getDimensionsSet().getWidth().getValue(), decisionService.getDimensionsSet().getHeight().getValue(), true); }
|
DMNValueFileExtensionIndexTerm implements ValueIndexTerm { @Override public String getTerm() { return TERM; } @Override String getTerm(); @Override String getValue(); @Override TermSearchType getSearchType(); }
|
@Test public void testGetTerm() { assertEquals(TERM, indexTerm.getTerm()); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override public ListBoxBaseDefinition getDefaultField() { return new StringListBoxFieldDefinition(); } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testGetDefaultField() { ListBoxBaseDefinition fieldDef = provider.getDefaultField(); assertEquals(StringListBoxFieldDefinition.class, fieldDef.getClass()); }
|
ListBoxFieldProvider extends SelectorFieldProvider<ListBoxBaseDefinition> { @Override public boolean isSupported(TypeInfo typeInfo) { return super.isSupported(typeInfo) || typeInfo.getType().equals(TypeKind.ENUM); } @Override Class<ListBoxFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override ListBoxBaseDefinition getDefaultField(); @Override ListBoxBaseDefinition createFieldByType(TypeInfo typeInfo); @Override boolean supports(Class clazz); @Override boolean isSupported(TypeInfo typeInfo); }
|
@Test public void testisSupported() { when(typeInfo.getType()).thenReturn(TypeKind.ENUM); assertTrue(provider.isSupported(typeInfo)); }
|
CharacterSelectorOption implements SelectorOption<Character> { public void setValue(Character value) { this.value = value; } CharacterSelectorOption(); CharacterSelectorOption(@MapsTo("value") Character value,
@MapsTo("text") String text); @Override Character getValue(); void setValue(Character value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetValue() { CharacterSelectorOption opt = new CharacterSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); }
|
CharacterSelectorOption implements SelectorOption<Character> { public void setText(String text) { this.text = text; } CharacterSelectorOption(); CharacterSelectorOption(@MapsTo("value") Character value,
@MapsTo("text") String text); @Override Character getValue(); void setValue(Character value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetText() { CharacterSelectorOption opt = new CharacterSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); }
|
RadioGroupFieldProvider extends SelectorFieldProvider<RadioGroupBaseDefinition> { @Override public RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo) { if (isSupported(typeInfo)) { String className = typeInfo.getClassName(); if (Byte.class.getName().equals(className) || byte.class.getName().equals(className) || Short.class.getName().equals(className) || short.class.getName().equals(className) || Integer.class.getName().equals(className) || int.class.getName().equals(className) || Long.class.getName().equals(className) || long.class.getName().equals(className) || BigInteger.class.getName().equals(className)) { return new IntegerRadioGroupFieldDefinition(); } if (Float.class.getName().equals(className) || float.class.getName().equals(className) || Double.class.getName().equals(className) || double.class.getName().equals(className) || BigDecimal.class.getName().equals(className)) { return new DecimalRadioGroupFieldDefinition(); } if (Character.class.getName().equals(className) || char.class.getName().equals(className)) { return new CharacterRadioGroupFieldDefinition(); } return getDefaultField(); } return null; } @Override Class<RadioGroupFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override RadioGroupBaseDefinition getDefaultField(); @Override RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo); }
|
@Test public void testCreateFieldByType() { testCreateFieldByType(byte.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(Byte.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(short.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(Short.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(int.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(Integer.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(long.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(Long.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(BigInteger.class, IntegerRadioGroupFieldDefinition.class); testCreateFieldByType(float.class, DecimalRadioGroupFieldDefinition.class); testCreateFieldByType(Float.class, DecimalRadioGroupFieldDefinition.class); testCreateFieldByType(double.class, DecimalRadioGroupFieldDefinition.class); testCreateFieldByType(Double.class, DecimalRadioGroupFieldDefinition.class); testCreateFieldByType(BigDecimal.class, DecimalRadioGroupFieldDefinition.class); testCreateFieldByType(char.class, CharacterRadioGroupFieldDefinition.class); testCreateFieldByType(Character.class, CharacterRadioGroupFieldDefinition.class); testCreateFieldByType(String.class, StringRadioGroupFieldDefinition.class); when(typeInfo.getClassName()).thenReturn(Boolean.class.getName()); assertNull(provider.createFieldByType(typeInfo)); }
|
RadioGroupFieldProvider extends SelectorFieldProvider<RadioGroupBaseDefinition> { @Override protected void doRegisterFields() { registerPropertyType(String.class); registerPropertyType(Character.class); registerPropertyType(char.class); registerPropertyType(BigDecimal.class); registerPropertyType(BigInteger.class); registerPropertyType(Byte.class); registerPropertyType(byte.class); registerPropertyType(Double.class); registerPropertyType(double.class); registerPropertyType(Float.class); registerPropertyType(float.class); registerPropertyType(Integer.class); registerPropertyType(int.class); registerPropertyType(Long.class); registerPropertyType(long.class); registerPropertyType(Short.class); registerPropertyType(short.class); } @Override Class<RadioGroupFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override RadioGroupBaseDefinition getDefaultField(); @Override RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo); }
|
@Test public void testDoRegisterFields() { provider.doRegisterFields(); Arrays.stream(SUPPORTED_TYPES).forEach(type -> { assertTrue(provider.supports(type)); }); }
|
RadioGroupFieldProvider extends SelectorFieldProvider<RadioGroupBaseDefinition> { @Override public int getPriority() { return 8; } @Override Class<RadioGroupFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override RadioGroupBaseDefinition getDefaultField(); @Override RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo); }
|
@Test public void testGetPriority() { assertEquals(8, provider.getPriority()); }
|
RadioGroupFieldProvider extends SelectorFieldProvider<RadioGroupBaseDefinition> { @Override public String getFieldTypeName() { return RadioGroupBaseDefinition.FIELD_TYPE.getTypeName(); } @Override Class<RadioGroupFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override RadioGroupBaseDefinition getDefaultField(); @Override RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo); }
|
@Test public void testGetFieldTypeName() { assertEquals(RadioGroupFieldType.NAME, provider.getFieldTypeName()); }
|
RadioGroupFieldProvider extends SelectorFieldProvider<RadioGroupBaseDefinition> { @Override public Class<RadioGroupFieldType> getFieldType() { return RadioGroupFieldType.class; } @Override Class<RadioGroupFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override RadioGroupBaseDefinition getDefaultField(); @Override RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo); }
|
@Test public void testGetFieldType() { assertEquals(RadioGroupFieldType.class, provider.getFieldType()); }
|
RadioGroupFieldProvider extends SelectorFieldProvider<RadioGroupBaseDefinition> { @Override public RadioGroupBaseDefinition getDefaultField() { return new StringRadioGroupFieldDefinition(); } @Override Class<RadioGroupFieldType> getFieldType(); @Override String getFieldTypeName(); @Override int getPriority(); @Override RadioGroupBaseDefinition getDefaultField(); @Override RadioGroupBaseDefinition createFieldByType(TypeInfo typeInfo); }
|
@Test public void testGetDefaultField() { RadioGroupBaseDefinition fieldDef = provider.getDefaultField(); assertEquals(StringRadioGroupFieldDefinition.class, fieldDef.getClass()); }
|
DMNDecisionServiceSVGShapeDefImpl implements DMNDecisionServiceSVGShapeDef { @Override public SizeHandler<DecisionService, SVGShapeView> newSizeHandler() { return new SizeHandler.Builder<DecisionService, SVGShapeView>().width(e -> e.getDimensionsSet().getWidth().getValue()) .height(e -> e.getDimensionsSet().getHeight().getValue()) .minWidth(p -> p.getDimensionsSet().getMinimumWidth()) .maxWidth(p -> p.getDimensionsSet().getMaximumWidth()) .minHeight(p -> p.getDividerLineY().getValue() + GeneralRectangleDimensionsSet.DEFAULT_HEIGHT) .maxHeight(p -> p.getDimensionsSet().getMaximumHeight()) .build(); } @Override Class<DMNDecisionServiceSVGViewFactory> getViewFactoryType(); @Override SizeHandler<DecisionService, SVGShapeView> newSizeHandler(); @Override FontHandler<DecisionService, SVGShapeView> newFontHandler(); @Override SVGShapeView<?> newViewInstance(final DMNDecisionServiceSVGViewFactory factory,
final DecisionService bean); @Override Glyph getGlyph(final Class<? extends DecisionService> type,
final Class<? extends ShapeFactory.GlyphConsumer> consumer,
final String defId); static final SVGShapeViewResources<DMNDefinition, DMNDecisionServiceSVGViewFactory> VIEW_RESOURCES; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_PALETTE; }
|
@Test @SuppressWarnings("unchecked") public void testNewSizeHandler() { final DecisionService decisionService = new DecisionService(); final View<DecisionService> view = new ViewImpl<>(decisionService, Bounds.create(0, 0, DEFAULT_WIDTH, DEFAULT_HEIGHT)); final SVGShapeView<?> shapeView = mock(SVGShapeView.class); final SizeHandler<DecisionService, SVGShapeView> handler = shapeDef.newSizeHandler(); handler.handle(view, shapeView); verify(shapeView).setMinWidth(decisionService.getDimensionsSet().getMinimumWidth()); verify(shapeView).setMaxWidth(decisionService.getDimensionsSet().getMaximumWidth()); verify(shapeView).setMinHeight(decisionService.getDividerLineY().getValue() + GeneralRectangleDimensionsSet.DEFAULT_HEIGHT); verify(shapeView).setMaxHeight(decisionService.getDimensionsSet().getMaximumHeight()); }
|
DecimalSelectorOption implements SelectorOption<Double> { public void setValue(Double value) { this.value = value; } DecimalSelectorOption(); DecimalSelectorOption(@MapsTo("value") Double value,
@MapsTo("text") String text); @Override Double getValue(); void setValue(Double value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetValue() { DecimalSelectorOption opt = new DecimalSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); }
|
DecimalSelectorOption implements SelectorOption<Double> { public void setText(String text) { this.text = text; } DecimalSelectorOption(); DecimalSelectorOption(@MapsTo("value") Double value,
@MapsTo("text") String text); @Override Double getValue(); void setValue(Double value); @Override String getText(); void setText(String text); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testSetText() { DecimalSelectorOption opt = new DecimalSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); }
|
SubFormFieldDefinition extends AbstractFieldDefinition implements HasNestedForm { @Override public void setNestedForm(String nestedForm) { this.nestedForm = nestedForm; } SubFormFieldDefinition(); @Override SubFormFieldType getFieldType(); @Override String getNestedForm(); @Override void setNestedForm(String nestedForm); @Override Container getContainer(); @Override void setContainer(Container container); @Override TypeInfo getFieldTypeInfo(); @Override boolean equals(Object o); @Override int hashCode(); static final SubFormFieldType FIELD_TYPE; }
|
@Test public void testValidation() { SubFormFieldDefinition fieldDefinition = getNewFieldDefinition(); Validator validator = Validation.buildDefaultValidatorFactory().getValidator(); Set<ConstraintViolation<SubFormFieldDefinition>> violations = validator.validate(fieldDefinition); assertEquals(0, violations.size()); fieldDefinition.setNestedForm(null); assertEquals(0, violations.size()); fieldDefinition.setNestedForm(""); assertEquals(0, violations.size()); }
|
TextAreaFieldInitializer implements FieldInitializer<TextAreaFieldDefinition> { @Override public void initialize(TextAreaFieldDefinition field, FieldElement fieldElement, FormGenerationContext context) { String rows = fieldElement.getParams().getOrDefault("rows", "3"); Integer value = Integer.valueOf(rows); if (value != null) { field.setRows(value); } } @Override boolean supports(FieldDefinition fieldDefinition); @Override void initialize(TextAreaFieldDefinition field,
FieldElement fieldElement,
FormGenerationContext context); }
|
@Test public void testInitializeWithParams() throws Exception { fieldElementParams.put(PLACEHOLDER_PARAM, PLACEHOLDER); fieldElementParams.put(ROWS_PARAM, ROWS); placeholderInitializer.initialize(field, fieldElement, context); rowsInitializer.initialize(field, fieldElement, context); verify(field).setPlaceHolder(any()); verify(field).setRows(any()); assertEquals(PLACEHOLDER, field.getPlaceHolder()); assertEquals(Integer.valueOf(ROWS), field.getRows()); }
|
SelectorFieldInitilizer implements FieldInitializer<SelectorFieldBaseDefinition> { @Override public void initialize(SelectorFieldBaseDefinition selectorFieldBaseDefinition, FieldElement fieldElement, FormGenerationContext context) { String dataProvider = fieldElement.getParams().get(SelectorDataProvider.class.getName()); if (dataProvider != null && !dataProvider.isEmpty()) { selectorFieldBaseDefinition.setDataProvider(dataProvider); } String relatedField = fieldElement.getParams().get("relatedField"); if (relatedField != null) { selectorFieldBaseDefinition.setRelatedField(relatedField); } } @Override boolean supports(FieldDefinition fieldDefinition); @Override void initialize(SelectorFieldBaseDefinition selectorFieldBaseDefinition,
FieldElement fieldElement,
FormGenerationContext context); }
|
@Test public void testInitialize() { fieldElementParams.put(DATA_PROVIDER, DATA_PROVIDER); fieldElementParams.put(RELATED_FIELD, RELATED_FIELD); initializer.initialize(field, fieldElement, context); verify(field).setDataProvider(anyString()); verify(field).setRelatedField(anyString()); assertEquals(DATA_PROVIDER, field.getDataProvider()); assertEquals(RELATED_FIELD, field.getRelatedField()); }
|
AbstractSliderFieldInitializer implements FieldInitializer<FIELD> { @Override public void initialize(FIELD field, FieldElement fieldElement, FormGenerationContext context) { String min = fieldElement.getParams().get("min"); T value = getValue(min); if (value != null) { field.setMin(value); } String max = fieldElement.getParams().get("max"); value = getValue(max); if (value != null) { field.setMax(value); } String precision = fieldElement.getParams().get("precision"); value = getValue(precision); if (value != null) { field.setPrecision(value); } String step = fieldElement.getParams().get("step"); value = getValue(step); if (value != null) { field.setStep(value); } } @Override void initialize(FIELD field,
FieldElement fieldElement,
FormGenerationContext context); }
|
@Test public void testInitializeWithoutParams() { initializer.initialize(field, fieldElement, context); verify(field, never()).setMin(any()); verify(field, never()).setMax(any()); verify(field, never()).setStep(any()); verify(field, never()).setPrecision(any()); }
|
FormBuildingServiceImpl implements FormBuildingService { @Override public FormDefinition generateFormForModel(Object model, FormElementFilter... filters) { if (model == null) { throw new IllegalArgumentException("Cannot generate form: Model cannot be null"); } return formGenerator.generateFormForModel(model, filters); } @Inject FormBuildingServiceImpl(FormGenerator formGenerator); @Override FormDefinition generateFormForModel(Object model, FormElementFilter... filters); @Override FormDefinition generateFormForClass(Class clazz, FormElementFilter... filters); @Override FormDefinition generateFormForClassName(String className, FormElementFilter... filters); }
|
@Test public void testGenerateFormForModel() { FormDefinition form = formBuildingService.generateFormForModel(model); testGeneratedForm(form, Person.class.getName()); }
|
FormBuildingServiceImpl implements FormBuildingService { @Override public FormDefinition generateFormForClass(Class clazz, FormElementFilter... filters) { if (clazz == null) { throw new IllegalArgumentException("Cannot generate form: Class cannot be null"); } return formGenerator.generateFormForClass(clazz, filters); } @Inject FormBuildingServiceImpl(FormGenerator formGenerator); @Override FormDefinition generateFormForModel(Object model, FormElementFilter... filters); @Override FormDefinition generateFormForClass(Class clazz, FormElementFilter... filters); @Override FormDefinition generateFormForClassName(String className, FormElementFilter... filters); }
|
@Test public void testGenerateFormForClass() { FormDefinition form = formBuildingService.generateFormForClass(Person.class); testGeneratedForm(form, Person.class.getName()); }
|
FormBuildingServiceImpl implements FormBuildingService { @Override public FormDefinition generateFormForClassName(String className, FormElementFilter... filters) { if (className == null) { throw new IllegalArgumentException("Cannot generate form: Class cannot be null"); } return formGenerator.generateFormForClassName(className, filters); } @Inject FormBuildingServiceImpl(FormGenerator formGenerator); @Override FormDefinition generateFormForModel(Object model, FormElementFilter... filters); @Override FormDefinition generateFormForClass(Class clazz, FormElementFilter... filters); @Override FormDefinition generateFormForClassName(String className, FormElementFilter... filters); }
|
@Test public void testGenerateFormForClassName() { FormDefinition form = formBuildingService.generateFormForClassName(Person.class.getName()); testGeneratedForm(form, Person.class.getName()); }
|
BackendPropertyValueExtractor extends AbstractPropertyValueExtractor { @Override protected Object readValue(Object model, String propertyName) { try { if (PropertyUtils.getPropertyDescriptor(model, propertyName) != null) { return PropertyUtils.getProperty(model, propertyName); } } catch (Exception e) { logger.warn("Error getting property '{}' from object '{}'", propertyName, model); logger.warn("Caused by:", e); } return null; } }
|
@Test public void testWithMyTestBean() { bean.setStringProperty(STRING_PROPERTY); bean.setIntProperty(INT_PROPERTY); bean.setBoolProperty(BOOL_PROPERTY); assertEquals(INT_PROPERTY, extractor.readValue(bean, "intProperty")); assertEquals(STRING_PROPERTY, extractor.readValue(bean, "stringProperty")); assertEquals(BOOL_PROPERTY, extractor.readValue(bean, "boolProperty")); }
@Test public void testWithWrongProperty() { assertNull(extractor.readValue(bean, "nonExistingProperty")); }
@Test public void testWithEmptyModel() { assertNull(extractor.readValue(null, null)); }
|
DMNDecisionServiceSVGShapeDefImpl implements DMNDecisionServiceSVGShapeDef { @Override public FontHandler<DecisionService, SVGShapeView> newFontHandler() { return new FontHandler.Builder<DecisionService, SVGShapeView>() .fontFamily(bean -> bean.getFontSet().getFontFamily().getValue()) .fontColor(bean -> bean.getFontSet().getFontColour().getValue()) .fontSize(bean -> bean.getFontSet().getFontSize().getValue()) .textWrapperStrategy(bean -> TextWrapperStrategy.TRUNCATE) .strokeAlpha(bean -> 0.0d) .verticalAlignment(bean -> HasTitle.VerticalAlignment.TOP) .horizontalAlignment(bean -> HasTitle.HorizontalAlignment.CENTER) .referencePosition(bean -> HasTitle.ReferencePosition.INSIDE) .orientation(bean -> HasTitle.Orientation.HORIZONTAL) .margin(HasTitle.VerticalAlignment.TOP, Y_OFFSET) .build(); } @Override Class<DMNDecisionServiceSVGViewFactory> getViewFactoryType(); @Override SizeHandler<DecisionService, SVGShapeView> newSizeHandler(); @Override FontHandler<DecisionService, SVGShapeView> newFontHandler(); @Override SVGShapeView<?> newViewInstance(final DMNDecisionServiceSVGViewFactory factory,
final DecisionService bean); @Override Glyph getGlyph(final Class<? extends DecisionService> type,
final Class<? extends ShapeFactory.GlyphConsumer> consumer,
final String defId); static final SVGShapeViewResources<DMNDefinition, DMNDecisionServiceSVGViewFactory> VIEW_RESOURCES; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_PALETTE; }
|
@Test @SuppressWarnings("unchecked") public void testNewFontHandler() { final DecisionService decisionService = new DecisionService(); final SVGShapeView<?> shapeView = mock(SVGShapeView.class); final FontHandler<DecisionService, SVGShapeView> handler = shapeDef.newFontHandler(); handler.handle(decisionService, shapeView); verify(shapeView).setTitlePosition(HasTitle.VerticalAlignment.TOP, HasTitle.HorizontalAlignment.CENTER, HasTitle.ReferencePosition.INSIDE, HasTitle.Orientation.HORIZONTAL); verify(shapeView).setMargins(new Maps.Builder().put(HasTitle.VerticalAlignment.TOP, 20.0).build()); verify(shapeView).setTextWrapper(TextWrapperStrategy.TRUNCATE); }
|
CrudComponent implements IsWidget { public FormDisplayer getFormDisplayer() { if (helper.showEmbeddedForms()) { return embeddedFormDisplayer; } return modalFormDisplayer; } @Inject CrudComponent(final CrudComponentView<MODEL, FORM_MODEL> view,
final EmbeddedFormDisplayer embeddedFormDisplayer,
final ModalFormDisplayer modalFormDisplayer,
final TranslationService translationService); void init(final CrudActionsHelper<MODEL> helper); FormDisplayer getFormDisplayer(); void createInstance(); void editInstance(int index); void deleteInstance(final int index); int getCurrentPage(); void refresh(); boolean isEmbedded(); void setEmbedded(final boolean embedded); @Override Widget asWidget(); void displayForm(final String title,
final IsFormView<FORM_MODEL> formView,
final FormDisplayer.FormDisplayerCallback callback); void displayForm(IsFormView<FORM_MODEL> formView,
FormDisplayerCallback callback); void restoreTable(); }
|
@Test public void usesEmbeddedDisplayerWhenShowEmbeddedFormsTrue() { initTest(); when(helper.showEmbeddedForms()).thenReturn(true); final FormDisplayer displayer = crudComponent.getFormDisplayer(); assertTrue(displayer.equals(embeddedFormDisplayer)); runFormTest(); }
@Test public void useModalDisplayerWhenShowEmbeddedFormsFalse() { initTest(); when(helper.showEmbeddedForms()).thenReturn(false); final FormDisplayer displayer = crudComponent.getFormDisplayer(); assertTrue(displayer.equals(modalFormDisplayer)); runFormTest(); }
|
CrudComponent implements IsWidget { public void createInstance() { helper.createInstance(); } @Inject CrudComponent(final CrudComponentView<MODEL, FORM_MODEL> view,
final EmbeddedFormDisplayer embeddedFormDisplayer,
final ModalFormDisplayer modalFormDisplayer,
final TranslationService translationService); void init(final CrudActionsHelper<MODEL> helper); FormDisplayer getFormDisplayer(); void createInstance(); void editInstance(int index); void deleteInstance(final int index); int getCurrentPage(); void refresh(); boolean isEmbedded(); void setEmbedded(final boolean embedded); @Override Widget asWidget(); void displayForm(final String title,
final IsFormView<FORM_MODEL> formView,
final FormDisplayer.FormDisplayerCallback callback); void displayForm(IsFormView<FORM_MODEL> formView,
FormDisplayerCallback callback); void restoreTable(); }
|
@Test public void createInstanceCallsHelperCreateInstance() { initTest(); crudComponent.createInstance(); verify(helper).createInstance(); }
|
CrudComponent implements IsWidget { public void editInstance(int index) { helper.editInstance(index); } @Inject CrudComponent(final CrudComponentView<MODEL, FORM_MODEL> view,
final EmbeddedFormDisplayer embeddedFormDisplayer,
final ModalFormDisplayer modalFormDisplayer,
final TranslationService translationService); void init(final CrudActionsHelper<MODEL> helper); FormDisplayer getFormDisplayer(); void createInstance(); void editInstance(int index); void deleteInstance(final int index); int getCurrentPage(); void refresh(); boolean isEmbedded(); void setEmbedded(final boolean embedded); @Override Widget asWidget(); void displayForm(final String title,
final IsFormView<FORM_MODEL> formView,
final FormDisplayer.FormDisplayerCallback callback); void displayForm(IsFormView<FORM_MODEL> formView,
FormDisplayerCallback callback); void restoreTable(); }
|
@Test public void editInstanceCallsHelperEditInstance() { initTest(); crudComponent.editInstance(0); verify(helper).editInstance(0); }
|
CrudComponent implements IsWidget { public void deleteInstance(final int index) { helper.deleteInstance(index); } @Inject CrudComponent(final CrudComponentView<MODEL, FORM_MODEL> view,
final EmbeddedFormDisplayer embeddedFormDisplayer,
final ModalFormDisplayer modalFormDisplayer,
final TranslationService translationService); void init(final CrudActionsHelper<MODEL> helper); FormDisplayer getFormDisplayer(); void createInstance(); void editInstance(int index); void deleteInstance(final int index); int getCurrentPage(); void refresh(); boolean isEmbedded(); void setEmbedded(final boolean embedded); @Override Widget asWidget(); void displayForm(final String title,
final IsFormView<FORM_MODEL> formView,
final FormDisplayer.FormDisplayerCallback callback); void displayForm(IsFormView<FORM_MODEL> formView,
FormDisplayerCallback callback); void restoreTable(); }
|
@Test public void deleteInstanceCallsHelperDeleteInstance() { initTest(); crudComponent.deleteInstance(0); verify(helper).deleteInstance(0); }
|
FormDefinitionSerializerImpl implements FormDefinitionSerializer { @Override public FormDefinition deserialize(String serializedForm) { GsonBuilder builder = new GsonBuilder(); builder.registerTypeAdapter(FormModel.class, formModelSerializer); builder.registerTypeAdapter(FieldDefinition.class, fieldSerializer); builder.registerTypeAdapter(ModelProperty.class, (JsonDeserializer<ModelProperty>) (json, typeOfT, context) -> context.deserialize(json, ModelPropertyImpl.class)); builder.registerTypeAdapter(TypeInfo.class, (JsonDeserializer<TypeInfo>) (json, typeOfT, context) -> context.deserialize(json, TypeInfoImpl.class)); builder.registerTypeAdapter(ModelMetaData.class, (JsonDeserializer<ModelMetaData>) (json, typeOfT, context) -> context.deserialize(json, ModelMetaDataImpl.class)); builder.registerTypeAdapter(MetaDataEntry.class, (JsonDeserializer<MetaDataEntry>) (json, typeOfT, context) -> { JsonObject jsonField = json.getAsJsonObject(); JsonElement jsonName = jsonField.get("name"); return context.deserialize(json, metaDataEntryManager.getMetaDataEntryClass(jsonName.getAsString())); }); Gson gson = builder.create(); return gson.fromJson(serializedForm, FormDefinition.class); } @Inject FormDefinitionSerializerImpl(FieldSerializer fieldSerializer,
FormModelSerializer formModelSerializer,
MetaDataEntryManager metaDataEntryManager); @Override String serialize(FormDefinition form); @Override FormDefinition deserialize(String serializedForm); }
|
@Test public void testFormDeSerialization() { String serializedForm = doSerializationTest(); FormDefinition deSerializedForm = definitionSerializer.deserialize(serializedForm); assertNotNull(deSerializedForm); assertEquals(formDefinition.getFields().size(), deSerializedForm.getFields().size()); for (FieldDefinition originalField : formDefinition.getFields()) { FieldDefinition resultField = deSerializedForm.getFieldById(originalField.getId()); assertNotNull(resultField); assertEquals(originalField.getClass(), resultField.getClass()); assertEquals(originalField.getName(), resultField.getName()); assertEquals(originalField.getLabel(), resultField.getLabel()); assertEquals(originalField.getStandaloneClassName(), resultField.getStandaloneClassName()); } }
|
DefaultValueListBoxRenderer implements Renderer<T> { @Override public String render(T value) { if(values == null || !values.containsKey(value)) { return NULL_STR; } return values.get(value); } void setValues(Map<T, String> values); @Override String render(T value); @Override void render(T value,
Appendable appendable); static final String NULL_STR; }
|
@Test public void testRenderWithoutOptions() throws Exception { renderer.render(NON_EXISTING_OPTION, appendable); verify(renderer, times(1)).render(NON_EXISTING_OPTION); verify(appendable, times(1)).append(DefaultValueListBoxRenderer.NULL_STR); }
@Test public void testRenderNullWithoutOptions() throws Exception { renderer.render(null, appendable); verify(renderer, times(1)).render(null); verify(appendable, times(1)).append(DefaultValueListBoxRenderer.NULL_STR); }
|
DMNDecisionServiceSVGShapeDefImpl implements DMNDecisionServiceSVGShapeDef { @Override public Glyph getGlyph(final Class<? extends DecisionService> type, final Class<? extends ShapeFactory.GlyphConsumer> consumer, final String defId) { if (org.kie.workbench.common.stunner.core.client.components.palette.AbstractPalette.PaletteGlyphConsumer.class.equals(consumer)) { return GLYPHS_PALETTE.computeIfAbsent(type, (t) -> ShapeGlyph.create()); } return getGlyph(type, defId); } @Override Class<DMNDecisionServiceSVGViewFactory> getViewFactoryType(); @Override SizeHandler<DecisionService, SVGShapeView> newSizeHandler(); @Override FontHandler<DecisionService, SVGShapeView> newFontHandler(); @Override SVGShapeView<?> newViewInstance(final DMNDecisionServiceSVGViewFactory factory,
final DecisionService bean); @Override Glyph getGlyph(final Class<? extends DecisionService> type,
final Class<? extends ShapeFactory.GlyphConsumer> consumer,
final String defId); static final SVGShapeViewResources<DMNDefinition, DMNDecisionServiceSVGViewFactory> VIEW_RESOURCES; static final Map<Class<? extends DMNDefinition>, Glyph> GLYPHS_PALETTE; }
|
@Test public void testGetToolboxGlyph() { assertThat(shapeDef.getGlyph(DecisionService.class, DEFINITION_ID)).isInstanceOf(ShapeGlyph.class); }
@Test public void testGetPaletteGlyphWithConsumer() { assertThat(shapeDef.getGlyph(DecisionService.class, PaletteGlyphConsumer.class, DEFINITION_ID)).isEqualTo(DMNSVGGlyphFactory.DECISION_SERVICE_PALETTE); }
|
DecimalBox implements IsWidget,
HasValue<Double> { @Override public void setValue(Double value) { setValue(value, false); } @Inject DecimalBox(DecimalBoxView view); @Override Double getValue(); @Override void setValue(Double value); @Override void setValue(Double value,
boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(ValueChangeHandler<Double> valueChangeHandler); @Override void fireEvent(GwtEvent<?> event); @Override Widget asWidget(); void notifyValueChange(String value); void setEnabled(boolean enabled); boolean isInvalidKeyCode(int key,
boolean isShiftPressed); void setId(String id); void setPlaceholder(String placeHolder); void setMaxLength(Integer maxLength); }
|
@Test public void testSetValueWithoutEvents() { decimalBox.setValue(TEST_VALUE_DOUBLE); verify(view).setValue(TEST_VALUE_STRING); }
|
DecimalBox implements IsWidget,
HasValue<Double> { public void setPlaceholder(String placeHolder) { view.setPlaceholder(placeHolder); } @Inject DecimalBox(DecimalBoxView view); @Override Double getValue(); @Override void setValue(Double value); @Override void setValue(Double value,
boolean fireEvents); @Override HandlerRegistration addValueChangeHandler(ValueChangeHandler<Double> valueChangeHandler); @Override void fireEvent(GwtEvent<?> event); @Override Widget asWidget(); void notifyValueChange(String value); void setEnabled(boolean enabled); boolean isInvalidKeyCode(int key,
boolean isShiftPressed); void setId(String id); void setPlaceholder(String placeHolder); void setMaxLength(Integer maxLength); }
|
@Test public void testSetPlaceholder() { String placeholder = "Random placeholder"; decimalBox.setPlaceholder(placeholder); verify(view).setPlaceholder(eq(placeholder)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.