method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
FormEditorHelper { public String generateUnboundFieldName(FieldDefinition field) { return UNBOUND_FIELD_NAME_PREFFIX + field.getId(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGenerateUnboundFieldName() { String fieldName = formEditorHelper.generateUnboundFieldName(nameField); assertEquals(fieldName, FormEditorHelper.UNBOUND_FIELD_NAME_PREFFIX + nameField.getId()); } |
### Question:
FormEditorHelper { public FormModelerContent getContent() { return content; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetContent() { FormModelerContent resContent = formEditorHelper.getContent(); assertEquals(resContent, content); } |
### Question:
FormEditorHelper { public FormDefinition getFormDefinition() { return content.getDefinition(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetFormDefinition() { FormDefinition formDefinition = formEditorHelper.getFormDefinition(); assertEquals(formDefinition, content.getDefinition()); } |
### Question:
MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override public Type<MoveDividerStepHandler> getAssociatedType() { return TYPE; } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); static final Type<MoveDividerStepHandler> TYPE; }### Answer:
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerStepEvent.TYPE); } |
### Question:
FormEditorHelper { public FormEditorRenderingContext getRenderingContext() { return content.getRenderingContext(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetRenderingContext() { FormEditorRenderingContext renderingContext = formEditorHelper.getRenderingContext(); assertEquals(renderingContext, content.getRenderingContext()); } |
### Question:
FormEditorHelper { public Map<String, FieldDefinition> getAvailableFields() { return availableFields; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetAvailableFields() { Map<String, FieldDefinition> availableFields = formEditorHelper.getAvailableFields(); assertEquals("There should be no available field", employeeFields.size(), availableFields.size()); } |
### Question:
FormEditorHelper { public FieldDefinition getFormField(String fieldId) { FieldDefinition result = content.getDefinition().getFieldById(fieldId); if (result == null) { result = availableFields.get(fieldId); if (result == null) { if (unbindedFields.containsKey(fieldId)) { Pair<EditorFieldLayoutComponent, FieldDefinition> pair = unbindedFields.get(fieldId); result = pair.getK2(); result.setLabel(result.getFieldType().getTypeName()); if (result instanceof HasPlaceHolder) { ((HasPlaceHolder) result).setPlaceHolder(result.getFieldType().getTypeName()); } unbindedFields.remove(result.getId()); FieldDefinition newField = fieldManager.getDefinitionByFieldType(result.getFieldType()); newField.setName(generateUnboundFieldName(newField)); EditorFieldLayoutComponent component = pair.getK1(); component.init(content.getRenderingContext(), newField); unbindedFields.put(newField.getId(), new Pair<>(component, newField)); } } } return result; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetFormField() { when(formDefinition.getFieldById(anyString())).thenReturn(nameField); content.setDefinition(formDefinition); FieldDefinition formField = formEditorHelper.getFormField(nameField.getId()); assertEquals(formField, nameField); } |
### Question:
FormEditorHelper { public Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables() { return unbindedFields.values().stream().map(Pair::getK1).collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetBaseFieldsDraggables() { Collection<EditorFieldLayoutComponent> draggables = formEditorHelper.getBaseFieldsDraggables(); assertNotNull(draggables); assertFalse(draggables.isEmpty()); } |
### Question:
FormEditorHelper { public void addAvailableField(FieldDefinition field) { if (modelContainsField(field)) { availableFields.put(field.getId(), field); } } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testAddAvailableField() { formEditorHelper.addAvailableField(employeeFields.get(0)); Map<String, FieldDefinition> availableFields = formEditorHelper.getAvailableFields(); assertEquals("The added field should be returned in available fields", employeeFields.size() + 1, availableFields.size()); } |
### Question:
FormEditorHelper { public List<String> getCompatibleModelFields(FieldDefinition field) { return availableFields.values() .stream() .filter(availableField -> availableField.getFieldTypeInfo().equals(field.getFieldTypeInfo())) .map(FieldDefinition::getBinding) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetCompatibleModelFields() { List<String> compatibleModelFields = formEditorHelper.getCompatibleModelFields(nameField); Assertions.assertThat(compatibleModelFields) .hasSize(2) .contains(lastNameField.getId(), nameField.getId()); compatibleModelFields = formEditorHelper.getCompatibleModelFields(ageField); Assertions.assertThat(compatibleModelFields).containsOnly(ageField.getId()); compatibleModelFields = formEditorHelper.getCompatibleModelFields(weightField); Assertions.assertThat(compatibleModelFields) .hasSize(1) .containsOnly(weightField.getId()); IntegerSliderDefinition slider = new IntegerSliderDefinition(); slider.setId("slider"); slider.setName("slider"); slider.setLabel("slider"); slider.setBinding("slider"); compatibleModelFields = formEditorHelper.getCompatibleModelFields(slider); Assertions.assertThat(compatibleModelFields) .hasSize(1) .containsOnly(ageField.getId()); } |
### Question:
FormEditorHelper { public List<String> getCompatibleFieldTypes(FieldDefinition field) { List<String> editorFieldTypeCodes = enabledFieldPropertiesFieldTypes.stream().map(FieldType::getTypeName).collect(Collectors.toList()); return fieldManager.getCompatibleFields(field).stream().filter((fieldCode) -> editorFieldTypeCodes.contains(fieldCode)) .collect(Collectors.toList()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testGetCompatibleFieldTypes() { Collection<String> fieldCodes = formEditorHelper.getCompatibleFieldTypes(nameField); assertFalse(fieldCodes.isEmpty()); } |
### Question:
FormEditorHelper { public FieldDefinition switchToField(FieldDefinition originalField, String newBinding) { if (newBinding != null && !"".equals(newBinding)) { Optional<FieldDefinition> availableFieldOptional = availableFields.values() .stream() .filter(availableField -> availableField.getBinding().equals(newBinding)).findFirst(); if (availableFieldOptional.isPresent()) { FieldDefinition availableField = availableFieldOptional.get(); FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); if (resultField == null) { resultField = fieldManager.getFieldFromProvider(availableField.getFieldType().getTypeName(), availableField.getFieldTypeInfo()); } resultField.copyFrom(originalField); resultField.setId(availableField.getId()); resultField.setName(availableField.getName()); resultField.setStandaloneClassName(availableField.getStandaloneClassName()); resultField.setBinding(newBinding); return resultField; } } FieldDefinition resultField = fieldManager.getFieldFromProvider(originalField.getFieldType().getTypeName(), originalField.getFieldTypeInfo()); if (newBinding == null || newBinding.equals("")) { resultField.setName(generateUnboundFieldName(resultField)); resultField.setBinding(""); } resultField.copyFrom(originalField); resultField.setBinding(newBinding); if (resultField.getName() == null) { resultField.setName(newBinding); } return resultField; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testSwitchToNullBinding() { FieldDefinition result = formEditorHelper.switchToField(nameField, null); Assertions.assertThat(result.getId()).isNotEqualTo(nameField.getId()); Assertions.assertThat(result.getName()).isNotEqualTo(nameField.getName()); Assertions.assertThat(result.getBinding()).isNullOrEmpty(); Assertions.assertThat(result.getBinding()).isNotEqualTo(nameField.getBinding()); Assertions.assertThat(result.getStandaloneClassName()).isEqualTo(nameField.getStandaloneClassName()); }
@Test public void testSwitchToDynamicBinding() { FieldDefinition result = formEditorHelper.switchToField(nameField, DYNAMIC_BINDING); Assertions.assertThat(result.getId()).isNotEqualTo(nameField.getId()); Assertions.assertThat(result.getName()).isEqualTo(DYNAMIC_BINDING); Assertions.assertThat(result.getBinding()).isEqualTo(DYNAMIC_BINDING); Assertions.assertThat(result.getStandaloneClassName()).isEqualTo(nameField.getStandaloneClassName()); } |
### Question:
FormEditorHelper { public FieldDefinition switchToFieldType(FieldDefinition field, String fieldCode) { FieldDefinition resultDefinition = fieldManager.getFieldFromProvider(fieldCode, field.getFieldTypeInfo()); resultDefinition.copyFrom(field); resultDefinition.setId(field.getId()); resultDefinition.setName(field.getName()); removeField(field.getId(), false); return resultDefinition; } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testSwitchToFieldType() { content.getDefinition().getFields().addAll(employeeFields); formEditorHelper.getAvailableFields().clear(); FieldDefinition fieldDefinition = formEditorHelper.switchToFieldType(nameField, TextAreaFieldDefinition.FIELD_TYPE.getTypeName()); assertEquals(TextAreaFieldDefinition.class, fieldDefinition.getClass()); } |
### Question:
MoveDividerStepEvent extends AbstractWiresDragEvent<MoveDividerStepHandler> { @Override protected void dispatch(final MoveDividerStepHandler handler) { handler.onMoveDividerStep(this); } MoveDividerStepEvent(final DecisionServiceSVGShapeView shape,
final AbstractNodeDragEvent<?> nodeDragEvent); @Override Type<MoveDividerStepHandler> getAssociatedType(); static final Type<MoveDividerStepHandler> TYPE; }### Answer:
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerStep(eq(event)); } |
### Question:
FormEditorHelper { public void removeAvailableField(FieldDefinition field) { availableFields.remove(field.getId()); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testRemoveAvailableField() { formEditorHelper.addAvailableField(nameField); assertTrue(formEditorHelper.getAvailableFields().containsKey(nameField.getId())); formEditorHelper.removeAvailableField(nameField); assertFalse(formEditorHelper.getAvailableFields().containsKey(nameField.getId())); } |
### Question:
FormEditorHelper { @PreDestroy public void destroy() { editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorHelper(FieldManager fieldManager,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
SyncBeanManager beanManager); FormModelerContent getContent(); void initHelper(FormModelerContent content); FormDefinition getFormDefinition(); FormModel getFormModel(); void addAvailableFields(); void addAvailableField(FieldDefinition field); void removeAvailableField(FieldDefinition field); FieldDefinition getFormField(String fieldId); void removeField(String fieldId,
boolean addToAvailables); boolean modelContainsField(FieldDefinition fieldDefinition); List<String> getCompatibleModelFields(FieldDefinition field); List<String> getCompatibleFieldTypes(FieldDefinition field); FieldDefinition switchToField(FieldDefinition originalField,
String newBinding); FieldDefinition switchToFieldType(FieldDefinition field,
String fieldCode); void saveFormField(FieldDefinition originalField,
FieldDefinition fieldCopy); String generateUnboundFieldName(FieldDefinition field); Collection<EditorFieldLayoutComponent> getBaseFieldsDraggables(); Map<String, FieldDefinition> getAvailableFields(); FormEditorRenderingContext getRenderingContext(); @PreDestroy void destroy(); static final String UNBOUND_FIELD_NAME_PREFFIX; }### Answer:
@Test public void testDestroy() { formEditorHelper.destroy(); verify(editorFieldLayoutComponents).destroyAll(); } |
### Question:
ChangesNotificationDisplayer implements ChangesNotificationDisplayerView.Presenter { public void show(FormModelerContent content, Command onClose) { PortablePreconditions.checkNotNull("content", content); PortablePreconditions.checkNotNull("onClose", onClose); if(content.getError() != null) { return; } this.content = content; this.onClose = onClose; this.canDisplay = false; checkNewModelFields(); checkContentConflicts(); if (canDisplay) { view.show(); } } @Inject ChangesNotificationDisplayer(ChangesNotificationDisplayerView view,
ConflictsDisplayer conflictsDisplayer,
NewPropertiesDisplayer newPropertiesDisplayer,
FieldManager fieldManager); void show(FormModelerContent content, Command onClose); @Override FormModel getFormModel(); @Override void close(); }### Answer:
@Test public void testShowWithModelError() { content.setError(mock(FormModelerContentError.class)); presenter.show(content, command); }
@Test public void testShowEmptySynchronization() { presenter.show(content, command); verify(view, never()).show(); } |
### Question:
SelectorOptionsProvider implements SystemSelectorDataProvider { @Override public SelectorData getSelectorData(FormRenderingContext context) { SelectorData data = new SelectorData<>(); Map<Object, String> values = new HashMap<>(); Object selectedValue = null; if (context.getModel() instanceof SelectorFieldBaseDefinition) { SelectorFieldBaseDefinition selector = (SelectorFieldBaseDefinition) context.getModel(); selectedValue = selector.getDefaultValue(); List<SelectorOption> options = selector.getOptions(); options.forEach(option -> values.put(option.getValue(), option.getText())); if (!values.containsKey(selectedValue)) { selectedValue = null; selector.setDefaultValue(null); } } data.setValues(values); data.setSelectedValue(selectedValue); return data; } @Override String getProviderName(); @Override SelectorData getSelectorData(FormRenderingContext context); }### Answer:
@Test public void testListBoxWithExistingDefaultValue() { when(field.getDefaultValue()).thenReturn(VAL_2); SelectorData<String> data = provider.getSelectorData(context); doTestVerifications(data); assertNotNull(data.getSelectedValue()); assertEquals(VAL_2, data.getSelectedValue()); }
@Test public void testListBoxWithoutDefaultValue() { SelectorData<String> data = provider.getSelectorData(context); doTestVerifications(data); assertNull(data.getSelectedValue()); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void loadContent() { editorService.call((RemoteCallback<FormModelerContent>) content -> doLoadContent(content), getNoSuchFileExceptionErrorCallback()).loadContent(versionRecordManager.getCurrentPath()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testLoad() { loadContent(); verify(layoutEditorMock).loadLayout(content.getDefinition().getLayoutTemplate()); verify(view).init(presenter); verify(view).setupLayoutEditor(layoutEditorMock); }
@Test public void testDataObjectsFields() { loadContent(); testAddRemoveDataTypeFields(); testDataTypeFieldProperties(); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { @OnMayClose public Boolean onMayClose() { return mayClose(editorHelper.getContent().getDefinition().hashCode()); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testMayClose() { testLoad(); assertTrue(presenter.onMayClose()); verify(view, never()).confirmClose(); testOnRemoveComponentWithContext(); assertFalse(presenter.onMayClose()); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { protected void removeAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); if (layoutDragComponentPalette.hasDraggableComponent(groupId, field.getId())) { layoutDragComponentPalette.removeDraggableComponent(groupId, field.getId()); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testRemoveAllDraggableGroupComponent() { loadContent(); addAllFields(); when(layoutDragComponentPaletteMock.hasDraggableComponent(anyString(), anyString())).thenReturn(true); List<FieldDefinition> fieldList = presenter.getFormDefinition().getFields(); presenter.removeAllDraggableGroupComponent(fieldList); verify(translationService, times(1)).getTranslation(FormEditorConstants.FormEditorPresenterModelFields); verify(layoutDragComponentPaletteMock, times(fieldList.size())).removeDraggableComponent(anyString(), anyString()); } |
### Question:
DecisionServiceSVGShapeView extends SVGShapeViewImpl { public double getDividerLineY() { return divider.getY(); } 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(); }### Answer:
@Test public void testGetDividerLineY() { assertThat(view.getDividerLineY()).isEqualTo(0.0); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { protected void addAllDraggableGroupComponent(Collection<FieldDefinition> fields) { String groupId = translationService.getTranslation(FormEditorConstants.FormEditorPresenterModelFields); Iterator<FieldDefinition> it = fields.iterator(); while (it.hasNext()) { FieldDefinition field = it.next(); EditorFieldLayoutComponent layoutFieldComponent = editorFieldLayoutComponents.get(); if (layoutFieldComponent != null) { layoutFieldComponent.init(editorHelper.getRenderingContext(), field); layoutDragComponentPalette.addDraggableComponent(groupId, field.getId(), layoutFieldComponent); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testAddAllDraggableGroupComponent() { loadContent(); List<FieldDefinition> fieldList = presenter.getFormDefinition().getFields(); presenter.addAllDraggableGroupComponent(fieldList); verify(layoutDragComponentPaletteMock, times(fieldList.size())).addDraggableComponent(anyString(), anyString(), any()); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { @PreDestroy public void destroy() { if (Objects.equals(FormEditorContext.getActiveEditorHelper(), editorHelper)) { FormEditorContext.setActiveEditorHelper(null); } editorFieldLayoutComponents.destroyAll(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testDestroy() { loadContent(); presenter.destroy(); verify(editorFieldLayoutComponents).destroyAll(); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { public LayoutTemplate getFormTemplate() { return layoutEditor.getLayout(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testGetFormTemplate() { loadContent(); presenter.getFormTemplate(); verify(layoutEditorMock).getLayout(); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected void save(String commitMessage) { synchronizeFormLayout(); editorService.call(getSaveSuccessCallback(editorHelper.getContent().getDefinition().hashCode())) .save(versionRecordManager.getCurrentPath(), editorHelper.getContent(), metadata, commitMessage); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testSave() { loadContent(); presenter.editorHelper.getContent().getDefinition().setLayoutTemplate(mock(LayoutTemplate.class)); presenter.save(""); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override @WorkbenchPartTitle public String getTitleText() { String fileName = FileNameUtil.removeExtension(versionRecordManager.getCurrentPath(), resourceType); return translationService.format(FormEditorConstants.FormEditorPresenterTitle, fileName); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testGetTitleText() { loadContent(); presenter.getTitleText(); verify(translationService).format(anyString(), any()); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { @Override protected Promise<Void> makeMenuBar() { if (workbenchContext.getActiveWorkspaceProject().isPresent()) { final WorkspaceProject activeProject = workbenchContext.getActiveWorkspaceProject().get(); return projectController.canUpdateProject(activeProject).then(canUpdateProject -> { if (canUpdateProject) { final ParameterizedCommand<Boolean> onSave = withComments -> { saveWithComments = withComments; saveAction(); }; fileMenuBuilder .addSave(versionRecordManager.newSaveMenuItem(onSave)) .addCopy(this::safeCopy) .addRename(this::safeRename) .addDelete(this::safeDelete); } addDownloadMenuItem(fileMenuBuilder); fileMenuBuilder .addNewTopLevelMenu(versionRecordManager.buildMenu()) .addNewTopLevelMenu(alertsButtonMenuItemBuilder.build()); return promises.resolve(); }); } return promises.resolve(); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testMakeMenuBar() { doReturn(Optional.of(mock(WorkspaceProject.class))).when(workbenchContext).getActiveWorkspaceProject(); doReturn(promises.resolve(true)).when(projectController).canUpdateProject(any()); loadContent(); verify(menuBuilderMock).addSave(any(MenuItem.class)); verify(menuBuilderMock).addCopy(any(Command.class)); verify(menuBuilderMock).addRename(any(Command.class)); verify(menuBuilderMock).addDelete(any(Command.class)); verify(menuBuilderMock).addNewTopLevelMenu(alertsButtonMenuItem); verify(menuBuilderMock).addNewTopLevelMenu(downloadMenuItem); presenter.getMenus(Assert::assertNotNull); verify(menuBuilderMock, atLeastOnce()).build(); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { public void rename(boolean save) { if (save) { synchronizeFormLayout(); } renamePopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getRenameCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testSafeRenameDirtySaving() { FormEditorPresenter presenterSpy = triggerSafeRename(true, true); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(true)); }
@Test public void testSafeRenameDirtyNotSaving() { FormEditorPresenter presenterSpy = triggerSafeRename(true, false); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(false)); }
@Test public void testSafeRenameNotDirty() { FormEditorPresenter presenterSpy = triggerSafeRename(false, false); verify(view, never()).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).rename(eq(false)); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { public void copy(boolean save) { if (save) { synchronizeFormLayout(); } copyPopUpPresenter.show(versionRecordManager.getPathToLatest(), assetUpdateValidator, getCopyCommand(save)); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testSafeCopyDirtySaving() { FormEditorPresenter presenterSpy = triggerSafeCopy(true, true); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(true)); }
@Test public void testSafeCopyDirtyNotSaving() { FormEditorPresenter presenterSpy = triggerSafeCopy(true, false); verify(view).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(false)); }
@Test public void testSafeCopyNotDirty() { FormEditorPresenter presenterSpy = triggerSafeCopy(false, false); verify(view, never()).showSavePopup(any(Path.class), any(Command.class), any(Command.class)); verify(presenterSpy).copy(eq(false)); } |
### Question:
DecisionServiceSVGShapeView extends SVGShapeViewImpl { public void setDividerLineY(final double y) { divider.setY(y); decisionServiceControlHandleFactory .getMoveDividerControlHandle() .ifPresent(handle -> handle.getControl().setY(y)); } 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(); }### Answer:
@Test public void testSetDividerLineY() { view.setDividerLineY(50.0); assertThat(getMoveDividerControlHandle().getControl().getY()).isEqualTo(50.0); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { protected void renameCommand(FileNameAndCommitMessage details, boolean save) { view.showBusyIndicator(org.kie.workbench.common.widgets.client.resources.i18n.CommonConstants.INSTANCE.Renaming()); editorService.call(getRenameSuccessCallback(renamePopUpPresenter.getView()), getRenameErrorCallback(renamePopUpPresenter.getView())).rename(versionRecordManager.getPathToLatest(), details.getNewFileName(), details.getCommitMessage(), save, editorHelper.getContent(), metadata); } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testRenameCommand() { loadContent(); FormEditorPresenter presenterSpy = spy(presenter); FileNameAndCommitMessage details = mock(FileNameAndCommitMessage.class); when(renamePopUpPresenter.getView()).thenReturn(mock(RenamePopUpPresenter.View.class)); doNothing().when(presenterSpy).doLoadContent(any(FormModelerContent.class)); presenterSpy.renameCommand(details, true); verify(view).showBusyIndicator(anyString()); verify(presenterSpy).getRenameErrorCallback(any(RenamePopUpPresenter.View.class)); verify(presenterSpy).getRenameSuccessCallback(any(RenamePopUpPresenter.View.class)); } |
### Question:
FormEditorPresenter extends KieEditor<FormModelerContent> { public void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent) { if (updatedLockStatusEvent.getFile().equals(versionRecordManager.getCurrentPath())) { if (updatedLockStatusEvent.isLocked() && !updatedLockStatusEvent.isLockedByCurrentUser()) { layoutEditor.lock(); } else { layoutEditor.unlock(); } } } @Inject FormEditorPresenter(FormEditorView view,
ChangesNotificationDisplayer changesNotificationDisplayer,
FormDefinitionResourceType resourceType,
Caller<FormEditorService> editorService,
TranslationService translationService,
ManagedInstance<EditorFieldLayoutComponent> editorFieldLayoutComponents,
ShowAssetUsagesDisplayer showAssetUsagesDisplayer,
ErrorMessageDisplayer errorMessageDisplayer,
LayoutEditorPropertiesPresenter layoutEditorPropertiesPresenter); @OnStartup void onStartup(final ObservablePath path,
final PlaceRequest place); @OnFocus void onFocus(); @Override void hideDocks(); void doLoadContent(final FormModelerContent content); @Override @WorkbenchPartTitle String getTitleText(); @WorkbenchMenu void getMenus(final Consumer<Menus> menusConsumer); @Override @WorkbenchPartView IsWidget getWidget(); void copy(boolean save); void rename(boolean save); LayoutTemplate getFormTemplate(); FormDefinition getFormDefinition(); void onRemoveComponent(@Observes ComponentRemovedEvent event); void onLayoutEditorElementSelectEvent(@Observes LayoutEditorElementSelectEvent event); void onSyncPalette(@Observes FormEditorSyncPaletteEvent event); void onSyncPalette(String formId); void safeDelete(); @OnMayClose Boolean onMayClose(); @PreDestroy void destroy(); void onLockStatusChange(@Observes UpdatedLockStatusEvent updatedLockStatusEvent); static final String ID; }### Answer:
@Test public void testOnLockStatusChange() { loadContent(); FormEditorPresenter presenterSpy = spy(presenter); UpdatedLockStatusEvent updatedLockStatusEvent = new UpdatedLockStatusEvent(versionRecordManager.getCurrentPath(), true,false); presenterSpy.onLockStatusChange(updatedLockStatusEvent); verify(layoutEditorMock).lock(); updatedLockStatusEvent = new UpdatedLockStatusEvent(versionRecordManager.getCurrentPath(), false, false); presenterSpy.onLockStatusChange(updatedLockStatusEvent); verify(layoutEditorMock).unlock(); } |
### Question:
DynamicFormModelGenerator { public StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters) { PortablePreconditions.checkNotNull("model", model); Optional<FormElementFilter[]> optional = Optional.ofNullable(filters); Stream<FormElementFilter> streamFilter = optional.map(value -> Stream.of(value)).orElseGet(Stream::empty); List<FormElementFilter> rootFormElemenFilters = new ArrayList<>(); List<FormElementFilter> nestedFormFilters = new ArrayList<>(); streamFilter.forEach(filter -> { if(!filter.getElementName().contains(".")) { rootFormElemenFilters.add(filter); } else { nestedFormFilters.add(filter); } }); FormDefinition formDefinition = formBuildingService.generateFormForModel(model, rootFormElemenFilters.stream().toArray(FormElementFilter[]::new)); if (formDefinition == null) { return null; } StaticModelFormRenderingContext context = new StaticModelFormRenderingContext(String.valueOf(System.currentTimeMillis())); context.setModel(model); context.setRootForm(formDefinition); if (context.getModel() != null) { initNestedFormSettings(formDefinition, context.getModel(), context, nestedFormFilters); } else { initNestedFormSettings(formDefinition,null, context, nestedFormFilters); } return context; } @Inject DynamicFormModelGenerator(FormBuildingService formBuildingService,
PropertyValueExtractor propertyValueExtractor); StaticModelFormRenderingContext getContextForModel(Object model, FormElementFilter... filters); }### Answer:
@Test public void testGenerateContextForModel() { StaticModelFormRenderingContext context = dynamicFormModelGenerator.getContextForModel(model); assertNotNull(context); assertNotNull(context.getRootForm()); assertEquals(3, context.getAvailableForms().size()); context.getAvailableForms().forEach((id, form) -> { testGeneratedForm(form, id); }); }
@Test public void testGenerateContextForModelWithFilters() { FormElementFilter nameFilter = new FormElementFilter("name", o -> true); FormElementFilter lastNameFilter = new FormElementFilter("lastName", o -> false); FormElementFilter addressStreetFilter = new FormElementFilter("address.street", o -> true); FormElementFilter addressNumFilter = new FormElementFilter("address.number", o -> false); StaticModelFormRenderingContext context = dynamicFormModelGenerator.getContextForModel(model, nameFilter, lastNameFilter, addressStreetFilter, addressNumFilter); assertEquals(3, context.getAvailableForms().size()); FormDefinition rootForm = context.getRootForm(); assertNotNull(rootForm); assertEquals(rootForm.getFields().size(), rootForm.getLayoutTemplate().getRows().size()); assertNotNull(rootForm.getFieldByBinding("name")); assertNull(rootForm.getFieldByBinding("lastName")); FormDefinition addressForm = context.getAvailableForms().get(Address.class.getName()); assertNotNull(addressForm); assertEquals(addressForm.getFields().size(), addressForm.getLayoutTemplate().getRows().size()); assertNotNull(addressForm.getFieldByBinding("street")); assertNull(addressForm.getFieldByBinding("number")); } |
### Question:
FormGeneratorDriver implements LayoutGeneratorDriver { @Override public IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent) { final LayoutDragComponent dragComponent = lookupComponent(layoutComponent); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getShowWidget(componentContext); } return null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); }### Answer:
@Test public void testCreateComponent() { HTMLElement column = mock(HTMLElement.class); LayoutComponent layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); driver.createComponent(column, layoutComponent); verify(beanManager).lookupBeans(anyString()); verify(instance).select(eq(FieldLayoutComponent.class)); verify(wrapperWidgetUtil).getWidget(same(driver), any(HTMLElement.class)); Assertions.assertThat(driver.getLayoutFields()) .hasSize(1); FieldLayoutComponent fieldLayoutComponent = driver.getLayoutFields().get(0); verify(fieldLayoutComponent).init(eq(context), any()); verify(fieldLayoutComponent).getShowWidget(any()); layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); driver.createComponent(column, layoutComponent); verify(beanManager, times(1)).lookupBeans(anyString()); verify(instance, times(2)).select(eq(FieldLayoutComponent.class)); verify(wrapperWidgetUtil, times(2)).getWidget(same(driver), any(HTMLElement.class)); Assertions.assertThat(driver.getLayoutFields()) .hasSize(2); fieldLayoutComponent = driver.getLayoutFields().get(1); verify(fieldLayoutComponent).init(eq(context), any()); verify(fieldLayoutComponent).getShowWidget(any()); } |
### Question:
FormGeneratorDriver implements LayoutGeneratorDriver { @Override public Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId) { FieldDefinition field = getFieldForLayoutComponent(layoutComponent); FieldLayoutComponent dragComponent = getFieldLayoutComponentForField(field); if (dragComponent != null) { Widget columnWidget = getWidget(column); RenderingContext componentContext = new RenderingContext(layoutComponent, columnWidget); return dragComponent.getContentPart(partId, componentContext); } return Optional.empty(); } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); }### Answer:
@Test public void testGetComponentPart() { testCreateComponent(); HTMLElement column = mock(HTMLElement.class); LayoutComponent layoutComponent = new LayoutComponent(FieldLayoutComponent.class.getName()); Optional<IsWidget> result = driver.getComponentPart(column, layoutComponent, ""); Assert.assertTrue(result.isPresent()); verify(wrapperWidgetUtil, times(3)).getWidget(same(driver), any(HTMLElement.class)); FieldLayoutComponent fieldLayoutComponent = driver.getLayoutFields().get(0); verify(fieldLayoutComponent).getContentPart(eq(""), any()); } |
### Question:
FormGeneratorDriver implements LayoutGeneratorDriver { public void clear() { layoutComponents.clear(); instance.destroyAll(); wrapperWidgetUtil.clear(this); componentsCache.clear(); renderingContext = null; } @Inject FormGeneratorDriver(SyncBeanManager beanManager, ManagedInstance<LayoutDragComponent> instance, FormsElementWrapperWidgetUtil wrapperWidgetUtil, Document document); FormRenderingContext getRenderingContext(); void setRenderingContext(FormRenderingContext renderingContext); @Override HTMLElement createContainer(); @Override HTMLElement createRow(LayoutRow layoutRow); @Override HTMLElement createColumn(LayoutColumn layoutColumn); @Override IsWidget createComponent(HTMLElement column, LayoutComponent layoutComponent); @Override Optional<IsWidget> getComponentPart(HTMLElement column, LayoutComponent layoutComponent, String partId); List<FieldLayoutComponent> getLayoutFields(); FieldLayoutComponent getFieldLayoutComponentForField(FieldDefinition field); void clear(); }### Answer:
@Test public void testClear() { driver.clear(); verify(instance).destroyAll(); verify(wrapperWidgetUtil).clear(same(driver)); } |
### Question:
SliderFieldRenderer extends FieldRenderer<SliderBaseDefinition, SliderFormGroup> implements RequiresValueConverter { @Override public Converter getConverter() { if (field.getStandaloneClassName() == Integer.class.getName() || field.getStandaloneClassName() == "int") { return new IntegerToDoubleConverter(); } return null; } @Override String getName(); @Override Converter getConverter(); }### Answer:
@Test public void testGetConverterInt() { when(fieldDefinition.getStandaloneClassName()).thenReturn("int"); Converter converter = fieldRenderer.getConverter(); assertNotNull(converter); assertThat(converter, instanceOf(IntegerToDoubleConverter.class)); } |
### Question:
DecisionServiceSVGShapeView extends SVGShapeViewImpl { @Override public HandlerManager getHandlerManager() { return super.getHandlerManager(); } 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(); }### Answer:
@Test public void testResize() { view.getHandlerManager().fireEvent(new WiresResizeStepEvent(view, nodeDragMoveEvent, 0, 0, WIDTH, HEIGHT)); assertThat(getMoveDividerControlHandle().getControl().getX()).isEqualTo(WIDTH / 2); } |
### Question:
TextBoxFieldRenderer extends FieldRenderer<TextBoxBaseDefinition, DefaultFormGroup> implements RequiresValueConverter { @Override protected FormGroup getFormGroup(RenderMode renderMode) { DefaultFormGroup formGroup = formGroupsInstance.get(); if (renderMode.equals(RenderMode.PRETTY_MODE)) { HTML html = new HTML(); formGroup.render(html, field); } else { String inputId = generateUniqueId(); textBox.setName(fieldNS); textBox.setId(inputId); textBox.setPlaceholder(field.getPlaceHolder()); textBox.setMaxLength(field.getMaxLength()); textBox.setEnabled(!field.getReadOnly()); registerFieldRendererPart(textBox); formGroup.render(inputId, textBox, field); } return formGroup; } @Override String getName(); @Override Converter getConverter(); }### Answer:
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); verify(textBox).setId(any()); verify(textBox).setName(anyString()); verify(textBox).setPlaceholder(eq(fieldDefinition.getPlaceHolder())); verify(textBox).setMaxLength(eq(fieldDefinition.getMaxLength())); verify(textBox).setEnabled(eq(!fieldDefinition.getReadOnly())); verify(formGroup).render(anyString(), eq(textBox), eq(fieldDefinition)); } |
### Question:
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { public void render(FormRenderingContext renderingContext) { formRenderer.render(renderingContext); } 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(); }### Answer:
@Test public void testRender() { subFormWidget.render(context); verify(formRenderer).render(same(context)); } |
### Question:
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public Object getValue() { return formRenderer.getModel(); } 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(); }### Answer:
@Test public void testGetValue() { subFormWidget.getValue(); verify(formRenderer).getModel(); } |
### Question:
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void setValue(Object value) { formRenderer.bind(value); } 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(); }### Answer:
@Test public void testSetValue() { final Object value = new Object(); subFormWidget.setValue(value); verify(formRenderer).bind(same(value)); } |
### Question:
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void clear() { formRenderer.unBind(); } 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(); }### Answer:
@Test public void testClear() { subFormWidget.clear(); verify(formRenderer).unBind(); } |
### Question:
SubFormWidget extends Composite implements TakesValue<Object>,
IsNestedModel,
NeedsFlush { @Override public void flush() { formRenderer.flush(); } 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(); }### Answer:
@Test public void testFlush() { subFormWidget.flush(); verify(formRenderer).flush(); } |
### Question:
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(); }### Answer:
@Test public void testAddFieldChangeHandler() { FieldChangeHandler handler = mock(FieldChangeHandler.class); subFormWidget.addFieldChangeHandler(handler); verify(formRenderer).addFieldChangeHandler(same(handler)); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@Test public void testIsValid() { subFormWidget.isValid(); verify(formRenderer).isValid(); } |
### Question:
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(); }### Answer:
@Test public void testGetFormGroup() { renderer.getFormGroup(RenderMode.EDIT_MODE); verify(formGroupsInstance).get(); multipleSubFormWidget.config(any(), any()); verify(formGroup).render(any(), any()); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@Test public void testGetConverter() { checkConverter(Float.class.getName(), FloatToDoubleConverter.class); checkConverter(float.class.getName(), FloatToDoubleConverter.class); checkConverter(BigDecimal.class.getName(), BigDecimalToDoubleConverter.class); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@Test public void testGetFormGroup() { testGetFormGroup(false); } |
### Question:
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(); }### Answer:
@Test public void testGetFormGroupReadOnly() { fieldDefinition.setReadOnly(true); testGetFormGroup(true); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
AbstractNumericEditableColumnGenerator extends AbstractEditableColumnGenerator<NUMBER> { protected abstract boolean doValidate(String flatValue, TableEntry<NUMBER> model, CellEditionHandler<NUMBER> cellEditionHandler); AbstractNumericEditableColumnGenerator(TranslationService translationService); }### Answer:
@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()); } |
### Question:
AbstractNumericEditableColumnGenerator extends AbstractEditableColumnGenerator<NUMBER> { protected abstract NUMBER doConvert(String flatValue); AbstractNumericEditableColumnGenerator(TranslationService translationService); }### Answer:
@Test public void testDoConvert() { String correctFlatValue = getCorrectFlatValue(); TYPE correctValue = getCorrectValue(); assertEquals(correctValue, generator.doConvert(correctFlatValue)); } |
### Question:
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); }### Answer:
@Test public void testGetEditableColumn() { testGetColumn(false); } |
### Question:
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; }### Answer:
@Test public void testGetAssociatedType() { assertThat(event.getAssociatedType()).isEqualTo(MoveDividerEndEvent.TYPE); } |
### Question:
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); }### Answer:
@Test public void testGetReadOnlyColumn() { testGetColumn(true); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@Test public void testGetPreviewWidget() { component.getPreviewWidget(mock(RenderingContext.class)); verify(renderer).renderWidget(); verify(content).clear(); verify(content).add(any(IsWidget.class)); } |
### Question:
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(); }### Answer:
@Test public void testGetShowWidget() { component.getShowWidget(mock(RenderingContext.class)); verify(renderer).renderWidget(); verify(content).clear(); verify(content).add(any(IsWidget.class)); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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(); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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; }### Answer:
@Test public void testDispatch() { event.dispatch(handler); verify(handler).onMoveDividerEnd(eq(event)); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
FieldRequired implements FieldRequiredView.Presenter,
IsElement { @Override public HTMLElement getElement() { return view.getElement(); } @Inject FieldRequired(FieldRequiredView view); @Override HTMLElement getElement(); }### Answer:
@Test public void testFunctionallity() { fieldRequired = new FieldRequired(view); fieldRequired.getElement(); verify(view).init(fieldRequired); verify(view).getElement(); } |
### Question:
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); }### Answer:
@Test public void testRenderWithInputId() { formGroup.render(INPUT_ID, widget, fieldDefinition); verify(view).render(INPUT_ID, widget, fieldDefinition); formGroup.getElement(); verify(view).getElement(); } |
### Question:
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(); }### Answer:
@Test public void testRenderMultipleTimes() { doBind(1); doBind(2); verify(formHandler).clear(); verify(view).clear(); } |
### Question:
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(); }### Answer:
@Test public void testFlush() { doBind(1); renderer.flush(); verify(formHandler).maybeFlush(); }
@Test public void testFlushWithoutInitializing() { renderer.flush(); verify(formHandler, never()).maybeFlush(); } |
### Question:
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(); }### Answer:
@Test public void testGetModel() { doBind(1); renderer.getModel(); verify(formHandler).getModel(); }
@Test public void testGetModelWithoutInitializing() { renderer.getModel(); verify(formHandler, never()).getModel(); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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); }### Answer:
@Test public void testWithoutParentContext() { SelectorData data = provider.getSelectorData(context); assertNotNull(data); assertNotNull(data.getValues()); assertTrue(data.getValues().isEmpty()); assertNull(data.getSelectedValue()); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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()); } }); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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(); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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); }### Answer:
@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()); } } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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("")); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@Test public void testSetValue() { StringSelectorOption opt = new StringSelectorOption(); opt.setValue(valueB); assertSame(valueB, opt.getValue()); } |
### Question:
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(); }### Answer:
@Test public void testSetText() { StringSelectorOption opt = new StringSelectorOption(); opt.setText(LABEL_B); assertSame(LABEL_B, opt.getText()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.