method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
DataTypeSelect { List<DataType> getDefaultDataTypes() { return dataTypeUtils.defaultDataTypes(); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testGetDefaultDataTypes() { final List<DataType> expectedDataTypes = new ArrayList<DataType>() {{ add(mock(DataType.class)); }}; when(dataTypeUtils.defaultDataTypes()).thenReturn(expectedDataTypes); final List<DataType> actualDataTypes = dataTypeSelect.getDefaultDataTypes(); assertThat(actualDataTypes).hasSameElementsAs(expectedDataTypes); } |
### Question:
DataTypeSelect { List<DataType> getCustomDataTypes() { return dataTypeUtils .customDataTypes() .stream() .filter(dataType -> !Objects.equals(dataType.getName(), getDataType().getName())) .collect(Collectors.toList()); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testGetCustomDataTypes() { final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); final List<DataType> customDataTypes = asList(dataType1, dataType2, dataType3); when(dataType1.getName()).thenReturn("tUUID"); when(dataType2.getName()).thenReturn("tPerson"); when(dataType3.getName()).thenReturn("tCity"); when(dataTypeUtils.customDataTypes()).thenReturn(customDataTypes); doReturn(dataType2).when(dataTypeSelect).getDataType(); final List<DataType> actualDataTypes = dataTypeSelect.getCustomDataTypes(); final List<DataType> expectedDataTypes = asList(dataType1, dataType3); assertEquals(expectedDataTypes, actualDataTypes); } |
### Question:
DataTypeSelect { void enableEditMode() { refresh(); view.enableEditMode(); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testEnableEditMode() { dataTypeSelect.enableEditMode(); verify(dataTypeSelect).refresh(); verify(view).enableEditMode(); } |
### Question:
DataTypeSelect { void disableEditMode() { view.disableEditMode(); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testDisableEditMode() { dataTypeSelect.disableEditMode(); verify(view).disableEditMode(); } |
### Question:
DataTypeSelect { void refresh() { view.setupDropdown(); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testRefresh() { dataTypeSelect.refresh(); verify(view).setupDropdown(); } |
### Question:
DataTypeSelect { void refreshView(final String typeName) { subDataTypes = dataTypeManager.from(getDataType()).makeExternalDataTypes(typeName); listItem.refreshSubItems(subDataTypes, false); listItem.refreshConstraintComponent(); listItem.expand(); subDataTypes.forEach(listItem::highlightLevel); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testRefreshView() { final String typeName = "typeName"; final DataType parent = mock(DataType.class); final DataType subDataType = mock(DataType.class); final List<DataType> expectedDataTypes = singletonList(subDataType); doReturn(parent).when(dataTypeSelect).getDataType(); when(dataTypeManager.from(parent)).thenReturn(dataTypeManager); when(dataTypeManager.makeExternalDataTypes(typeName)).thenReturn(expectedDataTypes); dataTypeSelect.init(listItem, parent); dataTypeSelect.refreshView(typeName); assertEquals(expectedDataTypes, dataTypeSelect.getSubDataTypes()); verify(listItem).refreshSubItems(expectedDataTypes, false); verify(listItem).refreshConstraintComponent(); verify(listItem).expand(); verify(listItem).highlightLevel(subDataType); } |
### Question:
DataTypeSelect { public String getValue() { return view.getValue(); } @Inject DataTypeSelect(final View view,
final DataTypeUtils dataTypeUtils,
final DataTypeManager dataTypeManager); HTMLElement getElement(); void init(final DataTypeListItem gridItem,
final DataType dataType); String getValue(); }### Answer:
@Test public void testGetValue() { final String expectedValue = "typeName"; when(view.getValue()).thenReturn(expectedValue); final String actualValue = dataTypeSelect.getValue(); assertEquals(expectedValue, actualValue); } |
### Question:
SmallSwitchComponentView implements SmallSwitchComponent.View { @EventHandler("input-checkbox") public void onInputCheckBoxChange(final ChangeEvent e) { callOnValueChanged(); } @Inject SmallSwitchComponentView(final HTMLInputElement inputCheckbox); @Override void init(final SmallSwitchComponent presenter); @EventHandler("input-checkbox") void onInputCheckBoxChange(final ChangeEvent e); @Override boolean getValue(); @Override void setValue(final boolean value); @Override void setOnValueChanged(final Consumer<Boolean> onValueChanged); }### Answer:
@Test public void testOnInputCheckBoxChange() { final ChangeEvent event = mock(ChangeEvent.class); view.onInputCheckBoxChange(event); verify(view).callOnValueChanged(); } |
### Question:
SmallSwitchComponentView implements SmallSwitchComponent.View { @Override public boolean getValue() { return isChecked(); } @Inject SmallSwitchComponentView(final HTMLInputElement inputCheckbox); @Override void init(final SmallSwitchComponent presenter); @EventHandler("input-checkbox") void onInputCheckBoxChange(final ChangeEvent e); @Override boolean getValue(); @Override void setValue(final boolean value); @Override void setOnValueChanged(final Consumer<Boolean> onValueChanged); }### Answer:
@Test public void testGetValueWhenCheckBoxIsChecked() { final boolean expectedValue = true; inputCheckbox.checked = expectedValue; final boolean actualValue = view.getValue(); assertEquals(expectedValue, actualValue); }
@Test public void testGetValueWhenCheckBoxIsNotChecked() { final boolean expectedValue = false; inputCheckbox.checked = expectedValue; final boolean actualValue = view.getValue(); assertEquals(expectedValue, actualValue); } |
### Question:
SmallSwitchComponentView implements SmallSwitchComponent.View { @Override public void setValue(final boolean value) { inputCheckbox.checked = value; } @Inject SmallSwitchComponentView(final HTMLInputElement inputCheckbox); @Override void init(final SmallSwitchComponent presenter); @EventHandler("input-checkbox") void onInputCheckBoxChange(final ChangeEvent e); @Override boolean getValue(); @Override void setValue(final boolean value); @Override void setOnValueChanged(final Consumer<Boolean> onValueChanged); }### Answer:
@Test public void testSetValue() { final boolean value = true; inputCheckbox.checked = false; view.setValue(value); assertEquals(value, inputCheckbox.checked); } |
### Question:
SmallSwitchComponent { public HTMLElement getElement() { return view.getElement(); } @Inject SmallSwitchComponent(final View view); HTMLElement getElement(); boolean getValue(); void setValue(final boolean value); void setOnValueChanged(final Consumer<Boolean> onValueChanged); }### Answer:
@Test public void testGetElement() { final HTMLElement expectedElement = mock(HTMLElement.class); when(view.getElement()).thenReturn(expectedElement); final HTMLElement actualElement = switchComponent.getElement(); assertEquals(expectedElement, actualElement); } |
### Question:
SmallSwitchComponent { public void setValue(final boolean value) { view.setValue(value); } @Inject SmallSwitchComponent(final View view); HTMLElement getElement(); boolean getValue(); void setValue(final boolean value); void setOnValueChanged(final Consumer<Boolean> onValueChanged); }### Answer:
@Test public void testSetValueWhenValueIsTrue() { final boolean value = true; switchComponent.setValue(value); verify(view).setValue(value); }
@Test public void testSetValueWhenValueIsFalse() { final boolean value = false; switchComponent.setValue(value); verify(view).setValue(value); } |
### Question:
SmallSwitchComponent { public boolean getValue() { return view.getValue(); } @Inject SmallSwitchComponent(final View view); HTMLElement getElement(); boolean getValue(); void setValue(final boolean value); void setOnValueChanged(final Consumer<Boolean> onValueChanged); }### Answer:
@Test public void testGetValueWhenValueIsTrue() { final boolean expectedValue = true; when(view.getValue()).thenReturn(expectedValue); final boolean actualValue = switchComponent.getValue(); assertEquals(expectedValue, actualValue); }
@Test public void testGetValueWhenValueIsFalse() { final boolean expectedValue = false; when(view.getValue()).thenReturn(expectedValue); final boolean actualValue = switchComponent.getValue(); assertEquals(expectedValue, actualValue); } |
### Question:
DelegatingGridWidgetDndMouseMoveHandler extends GridWidgetDnDMouseMoveHandler { @Override protected void findMovableRows(final GridWidget view, final BaseGridRendererHelper.RenderingInformation renderingInformation, final double cx, final double cy) { super.findMovableRows(view, renderingInformation, cx, cy); if (view instanceof HasRowDragRestrictions) { final HasRowDragRestrictions hasRowDragRestrictions = (HasRowDragRestrictions) view; if (!hasRowDragRestrictions.isRowDragPermitted(state)) { state.reset(); layer.getViewport().getElement().getStyle().setCursor(state.getCursor()); } } } DelegatingGridWidgetDndMouseMoveHandler(final GridLayer layer,
final GridWidgetDnDHandlersState state); }### Answer:
@Test public void testDelegationToGridWidget() { final GridWidget view = mock(GridWidget.class); doReturn(rendererHelper).when(view).getRendererHelper(); handler.findMovableRows(view, rendererHelper.getRenderingInformation(), 0, 0); verify(state, never()).reset(); }
@Test public void testDelegationToHasRowDragRestrictionsWhenPermitted() { final ContextGrid view = mock(ContextGrid.class); doReturn(rendererHelper).when(view).getRendererHelper(); doReturn(true).when(view).isRowDragPermitted(eq(state)); handler.findMovableRows(view, rendererHelper.getRenderingInformation(), 0, 0); verify(state, never()).reset(); }
@Test public void testDelegationToHasRowDragRestrictionsWhenNotPermitted() { final ContextGrid view = mock(ContextGrid.class); doReturn(rendererHelper).when(view).getRendererHelper(); doReturn(false).when(view).isRowDragPermitted(eq(state)); doReturn(Style.Cursor.DEFAULT).when(state).getCursor(); doReturn(viewport).when(gridLayer).getViewport(); doReturn(element).when(viewport).getElement(); doReturn(style).when(element).getStyle(); handler.findMovableRows(view, rendererHelper.getRenderingInformation(), 0, 0); verify(state).reset(); verify(style).setCursor(eq(Style.Cursor.DEFAULT)); } |
### Question:
ListItemViewCssHelper { public static void asRightArrow(final Element element) { element.classList.add(RIGHT_ARROW_CSS_CLASS); element.classList.remove(DOWN_ARROW_CSS_CLASS); } static void asRightArrow(final Element element); static void asDownArrow(final Element element); static boolean isRightArrow(final Element element); static void asFocusedDataType(final Element element); static void asNonFocusedDataType(final Element element); static boolean isFocusedDataType(final Element element); static final String RIGHT_ARROW_CSS_CLASS; static final String DOWN_ARROW_CSS_CLASS; static final String FOCUSED_CSS_CLASS; }### Answer:
@Test public void testAsRightArrow() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; ListItemViewCssHelper.asRightArrow(element); verify(classList).add(RIGHT_ARROW_CSS_CLASS); verify(classList).remove(DOWN_ARROW_CSS_CLASS); } |
### Question:
ListItemViewCssHelper { public static void asDownArrow(final Element element) { element.classList.remove(RIGHT_ARROW_CSS_CLASS); element.classList.add(DOWN_ARROW_CSS_CLASS); } static void asRightArrow(final Element element); static void asDownArrow(final Element element); static boolean isRightArrow(final Element element); static void asFocusedDataType(final Element element); static void asNonFocusedDataType(final Element element); static boolean isFocusedDataType(final Element element); static final String RIGHT_ARROW_CSS_CLASS; static final String DOWN_ARROW_CSS_CLASS; static final String FOCUSED_CSS_CLASS; }### Answer:
@Test public void testAsDownArrow() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; ListItemViewCssHelper.asDownArrow(element); verify(classList).add(DOWN_ARROW_CSS_CLASS); verify(classList).remove(RIGHT_ARROW_CSS_CLASS); } |
### Question:
ListItemViewCssHelper { public static boolean isRightArrow(final Element element) { return element.classList.contains(RIGHT_ARROW_CSS_CLASS); } static void asRightArrow(final Element element); static void asDownArrow(final Element element); static boolean isRightArrow(final Element element); static void asFocusedDataType(final Element element); static void asNonFocusedDataType(final Element element); static boolean isFocusedDataType(final Element element); static final String RIGHT_ARROW_CSS_CLASS; static final String DOWN_ARROW_CSS_CLASS; static final String FOCUSED_CSS_CLASS; }### Answer:
@Test public void testIsRightArrowWhenItIsRightArrow() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; when(classList.contains(RIGHT_ARROW_CSS_CLASS)).thenReturn(true); assertTrue(ListItemViewCssHelper.isRightArrow(element)); }
@Test public void testIsRightArrowWhenItIsNotRightArrow() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; when(classList.contains(RIGHT_ARROW_CSS_CLASS)).thenReturn(false); assertFalse(ListItemViewCssHelper.isRightArrow(element)); } |
### Question:
ListItemViewCssHelper { public static void asFocusedDataType(final Element element) { element.classList.add(FOCUSED_CSS_CLASS); } static void asRightArrow(final Element element); static void asDownArrow(final Element element); static boolean isRightArrow(final Element element); static void asFocusedDataType(final Element element); static void asNonFocusedDataType(final Element element); static boolean isFocusedDataType(final Element element); static final String RIGHT_ARROW_CSS_CLASS; static final String DOWN_ARROW_CSS_CLASS; static final String FOCUSED_CSS_CLASS; }### Answer:
@Test public void testAsFocusedDataType() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; ListItemViewCssHelper.asFocusedDataType(element); verify(classList).add(FOCUSED_CSS_CLASS); } |
### Question:
ListItemViewCssHelper { public static void asNonFocusedDataType(final Element element) { element.classList.remove(FOCUSED_CSS_CLASS); } static void asRightArrow(final Element element); static void asDownArrow(final Element element); static boolean isRightArrow(final Element element); static void asFocusedDataType(final Element element); static void asNonFocusedDataType(final Element element); static boolean isFocusedDataType(final Element element); static final String RIGHT_ARROW_CSS_CLASS; static final String DOWN_ARROW_CSS_CLASS; static final String FOCUSED_CSS_CLASS; }### Answer:
@Test public void testAsNonFocusedDataType() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; ListItemViewCssHelper.asNonFocusedDataType(element); verify(classList).remove(FOCUSED_CSS_CLASS); } |
### Question:
ListItemViewCssHelper { public static boolean isFocusedDataType(final Element element) { return element.classList.contains(FOCUSED_CSS_CLASS); } static void asRightArrow(final Element element); static void asDownArrow(final Element element); static boolean isRightArrow(final Element element); static void asFocusedDataType(final Element element); static void asNonFocusedDataType(final Element element); static boolean isFocusedDataType(final Element element); static final String RIGHT_ARROW_CSS_CLASS; static final String DOWN_ARROW_CSS_CLASS; static final String FOCUSED_CSS_CLASS; }### Answer:
@Test public void testIsFocusedDataTypeWhenItIsFocused() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; when(classList.contains(FOCUSED_CSS_CLASS)).thenReturn(true); assertTrue(ListItemViewCssHelper.isFocusedDataType(element)); }
@Test public void testIsFocusedDataTypeWhenItIsNotFocused() { final Element element = mock(Element.class); final DOMTokenList classList = mock(DOMTokenList.class); element.classList = classList; when(classList.contains(FOCUSED_CSS_CLASS)).thenReturn(false); assertFalse(ListItemViewCssHelper.isFocusedDataType(element)); } |
### Question:
MenuInitializer { public void init() { final Element dropdown = dropdown(); jQuery(dropdown).on("show.bs.dropdown", moveDropDownToBody()); jQuery(dropdown).on("hidden.bs.dropdown", moveDropDownToKebabContainer()); } MenuInitializer(final Element menu,
final String dropDownClass); void init(); }### Answer:
@Test public void testInit() { final JQuery jQuery = mock(JQuery.class); final JQuery.CallbackFunction moveDropDownToBody = mock(JQuery.CallbackFunction.class); final JQuery.CallbackFunction moveDropDownToKebabContainer = mock(JQuery.CallbackFunction.class); final Element dropdown = mock(Element.class); doReturn(dropdown).when(initializer).dropdown(); doReturn(moveDropDownToBody).when(initializer).moveDropDownToBody(); doReturn(moveDropDownToKebabContainer).when(initializer).moveDropDownToKebabContainer(); doReturn(jQuery).when(initializer).jQuery(dropdown); initializer.init(); verify(jQuery).on("show.bs.dropdown", moveDropDownToBody); verify(jQuery).on("hidden.bs.dropdown", moveDropDownToKebabContainer); } |
### Question:
DMNPathsHelperImpl implements DMNPathsHelper { DirectoryStream.Filter<org.uberfire.java.nio.file.Path> dmnModelFilter() { return path -> importTypesHelper.isDMN(convertPath(path)); } DMNPathsHelperImpl(); @Inject DMNPathsHelperImpl(final RefactoringQueryService refactoringQueryService,
final DMNImportTypesHelper importTypesHelper,
final @Named("ioStrategy") IOService ioService); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override String getRelativeURI(final Path dmnModelPath,
final Path includedModelPath); }### Answer:
@Test public void testDMNModelFilter() { final DirectoryStream.Filter<org.uberfire.java.nio.file.Path> filter = pathsHelper.dmnModelFilter(); final org.uberfire.java.nio.file.Path nioPath1 = mock(org.uberfire.java.nio.file.Path.class); final org.uberfire.java.nio.file.Path nioPath2 = mock(org.uberfire.java.nio.file.Path.class); final Path path1 = mock(Path.class); final Path path2 = mock(Path.class); when(path1.getFileName()).thenReturn("/Users/karreiro/projects/dmn-project/file.dmn"); when(path2.getFileName()).thenReturn("/Users/karreiro/projects/dmn-project/Readme.md"); doReturn(path1).when(pathsHelper).convertPath(nioPath1); doReturn(path2).when(pathsHelper).convertPath(nioPath2); assertTrue(filter.accept(nioPath1)); assertFalse(filter.accept(nioPath2)); } |
### Question:
MenuInitializer { JQuery.CallbackFunction moveDropDownToBody() { return (event) -> { final JavaScriptObject properties = bodyDropdownProperties(event).getJavaScriptObject(); JQuery $ = jQuery(body()); JQuery css = jQuery(event.target).css(properties); JQuery detach = css.detach(); $.append(detach); }; } MenuInitializer(final Element menu,
final String dropDownClass); void init(); }### Answer:
@Test public void testMoveDropDownToBody() { final HTMLElement modalInElement = mock(HTMLElement.class); final HTMLElement target = mock(HTMLElement.class); final JQuery jQueryModalIn = mock(JQuery.class); final JQuery jQueryTarget = mock(JQuery.class); final JQuery jQueryCSS = mock(JQuery.class); final JQuery jQueryDetach = mock(JQuery.class); final JQueryEvent event = mock(JQueryEvent.class); final JSONObject jsonObjectProperties = mock(JSONObject.class); final JavaScriptObject javaScriptObjectProperties = mock(JavaScriptObject.class); event.target = target; doReturn(jsonObjectProperties).when(initializer).bodyDropdownProperties(event); doReturn(modalInElement).when(initializer).body(); when(jsonObjectProperties.getJavaScriptObject()).thenReturn(javaScriptObjectProperties); when(jQueryTarget.css(javaScriptObjectProperties)).thenReturn(jQueryCSS); when(jQueryCSS.detach()).thenReturn(jQueryDetach); when(initializer.jQuery(modalInElement)).thenReturn(jQueryModalIn); when(initializer.jQuery(target)).thenReturn(jQueryTarget); initializer.moveDropDownToBody().call(event); verify(jQueryModalIn).append(jQueryDetach); } |
### Question:
MenuInitializer { JQuery.CallbackFunction moveDropDownToKebabContainer() { return (event) -> { final JavaScriptObject properties = emptyProperties().getJavaScriptObject(); jQuery(menu).append(jQuery(event.target).css(properties).detach()); }; } MenuInitializer(final Element menu,
final String dropDownClass); void init(); }### Answer:
@Test public void testMoveDropDownToKebabContainer() { final HTMLElement modalInElement = mock(HTMLElement.class); final HTMLElement target = mock(HTMLElement.class); final JQuery jQueryModalIn = mock(JQuery.class); final JQuery jQueryTarget = mock(JQuery.class); final JQuery jQueryCSS = mock(JQuery.class); final JQuery jQueryDetach = mock(JQuery.class); final JQueryEvent event = mock(JQueryEvent.class); final JSONObject jsonObjectProperties = mock(JSONObject.class); final JavaScriptObject javaScriptObjectProperties = mock(JavaScriptObject.class); event.target = target; doReturn(jsonObjectProperties).when(initializer).emptyProperties(); doReturn(modalInElement).when(initializer).body(); when(jsonObjectProperties.getJavaScriptObject()).thenReturn(javaScriptObjectProperties); when(jQueryTarget.css(javaScriptObjectProperties)).thenReturn(jQueryCSS); when(jQueryCSS.detach()).thenReturn(jQueryDetach); when(initializer.jQuery(kebabMenu)).thenReturn(jQueryModalIn); when(initializer.jQuery(target)).thenReturn(jQueryTarget); initializer.moveDropDownToKebabContainer().call(event); verify(jQueryModalIn).append(jQueryDetach); } |
### Question:
MenuInitializer { JSONObject bodyDropdownProperties(final JQueryEvent e) { final JSONObject jsonObject = makeJsonObject(); jsonObject.put("position", new JSONString("absolute")); jsonObject.put("left", new JSONNumber(offsetLeft(e.target))); jsonObject.put("top", new JSONNumber(offsetTop(e.target))); jsonObject.put("z-index", new JSONNumber(1051)); return jsonObject; } MenuInitializer(final Element menu,
final String dropDownClass); void init(); }### Answer:
@Test public void testBodyDropdownProperties() { final JQueryEvent event = mock(JQueryEvent.class); final HTMLElement target = mock(HTMLElement.class); final double left = 1; final double top = 1; final double zIndex = 1051; final JSONObject expectedJSONObject = mock(JSONObject.class); doReturn(expectedJSONObject).when(initializer).makeJsonObject(); event.target = target; doReturn(left).when(initializer).offsetLeft(target); doReturn(top).when(initializer).offsetTop(target); doReturn(top).when(initializer).offsetTop(target); final JSONObject actualJSONObject = initializer.bodyDropdownProperties(event); verify(expectedJSONObject).put("position", new JSONString("absolute")); verify(expectedJSONObject).put("left", new JSONNumber(left)); verify(expectedJSONObject).put("top", new JSONNumber(top)); verify(expectedJSONObject).put("z-index", new JSONNumber(zIndex)); assertEquals(expectedJSONObject, actualJSONObject); } |
### Question:
MenuInitializer { JSONObject emptyProperties() { final JSONObject jsonObject = makeJsonObject(); jsonObject.put("position", new JSONString("")); jsonObject.put("left", new JSONString("")); jsonObject.put("top", new JSONString("")); jsonObject.put("z-index", new JSONString("")); return jsonObject; } MenuInitializer(final Element menu,
final String dropDownClass); void init(); }### Answer:
@Test public void testEmptyProperties() { final JSONObject expectedJSONObject = mock(JSONObject.class); doReturn(expectedJSONObject).when(initializer).makeJsonObject(); final JSONObject actualJSONObject = initializer.emptyProperties(); verify(expectedJSONObject).put("position", new JSONString("")); verify(expectedJSONObject).put("left", new JSONString("")); verify(expectedJSONObject).put("top", new JSONString("")); verify(expectedJSONObject).put("z-index", new JSONString("")); assertEquals(expectedJSONObject, actualJSONObject); } |
### Question:
DataTypeStackHash { public String calculateHash(final DataType dataType) { return calculateHash(dataType, dataType.getName()); } @Inject DataTypeStackHash(final DataTypeStore dataTypeStore); String calculateHash(final DataType dataType); String calculateParentHash(final DataType reference); }### Answer:
@Test public void testCalculateHash() { assertEquals("tCity", dataTypeStackHash.calculateHash(tCity)); assertEquals("tCity.id", dataTypeStackHash.calculateHash(tCityId)); assertEquals("tCity.name", dataTypeStackHash.calculateHash(tCityName)); assertEquals("tPerson", dataTypeStackHash.calculateHash(tPerson)); assertEquals("tPerson.id", dataTypeStackHash.calculateHash(tPersonId)); assertEquals("tPerson.name", dataTypeStackHash.calculateHash(tPersonName)); assertEquals("tPerson.city", dataTypeStackHash.calculateHash(tPersonCity)); assertEquals("tPerson.city.id", dataTypeStackHash.calculateHash(tPersonCityId)); assertEquals("tPerson.city.name", dataTypeStackHash.calculateHash(tPersonCityName)); } |
### Question:
DataTypeStackHash { public String calculateParentHash(final DataType reference) { return getParent(reference) .map(dataType -> calculateHash(dataType, dataType.getName())) .orElse(""); } @Inject DataTypeStackHash(final DataTypeStore dataTypeStore); String calculateHash(final DataType dataType); String calculateParentHash(final DataType reference); }### Answer:
@Test public void testCalculateParentHash() { index(tCity, tCityId, tCityName, tPerson, tPersonId, tPersonName, tPersonCity, tPersonCityId, tPersonCityName); assertEquals("", dataTypeStackHash.calculateParentHash(tCity)); assertEquals("tCity", dataTypeStackHash.calculateParentHash(tCityId)); assertEquals("tCity", dataTypeStackHash.calculateParentHash(tCityName)); assertEquals("", dataTypeStackHash.calculateParentHash(tPerson)); assertEquals("tPerson", dataTypeStackHash.calculateParentHash(tPersonId)); assertEquals("tPerson", dataTypeStackHash.calculateParentHash(tPersonName)); assertEquals("tPerson", dataTypeStackHash.calculateParentHash(tPersonCity)); assertEquals("tPerson.city", dataTypeStackHash.calculateParentHash(tPersonCityId)); assertEquals("tPerson.city", dataTypeStackHash.calculateParentHash(tPersonCityName)); } |
### Question:
WarningMessage { FlashMessage getFlashMessage(final DataType dataType, final Command onSuccess, final Command onError) { return new FlashMessage(WARNING, getStrongMessage(dataType), getRegularMessage(), getErrorElementSelector(dataType), onSuccess, onError); } WarningMessage(final TranslationService translationService); }### Answer:
@Test public void testGetFlashMessage() { final String uuid = "uuid"; final FlashMessage.Type expectedType = WARNING; final String expectedStrongMessage = "expectedStrongMessage"; final String expectedRegularMessage = "expectedRegularMessage"; final String expectedErrorElementSelector = "[data-row-uuid=\"uuid\"] .bootstrap-select"; final Command expectedOnSuccessCallback = mock(Command.class); final Command expectedOnErrorCallback = mock(Command.class); final DataType dataType = mock(DataType.class); final WarningMessage errorMessage = new WarningMessage(translationService) { @Override String getStrongMessage(final DataType dataType) { return expectedStrongMessage; } @Override String getRegularMessage() { return expectedRegularMessage; } }; when(dataType.getUUID()).thenReturn(uuid); final FlashMessage flashMessage = errorMessage.getFlashMessage(dataType, expectedOnSuccessCallback, expectedOnErrorCallback); final FlashMessage.Type actualType = flashMessage.getType(); final String actualStrongMessage = flashMessage.getStrongMessage(); final String actualRegularMessage = flashMessage.getRegularMessage(); final String actualErrorElementSelector = flashMessage.getElementSelector(); final Command actualOnSuccessCallback = flashMessage.getOnSuccess(); final Command actualOnErrorCallback = flashMessage.getOnError(); assertEquals(expectedType, actualType); assertEquals(expectedStrongMessage, actualStrongMessage); assertEquals(expectedRegularMessage, actualRegularMessage); assertEquals(expectedErrorElementSelector, actualErrorElementSelector); assertEquals(expectedOnSuccessCallback, actualOnSuccessCallback); assertEquals(expectedOnErrorCallback, actualOnErrorCallback); } |
### Question:
ReferencedDataTypeWarningMessage extends WarningMessage { @Override String getStrongMessage(final DataType dataType) { return translationService.format(ReferencedDataTypeWarningMessage_StrongMessage, dataType.getName()); } @Inject ReferencedDataTypeWarningMessage(final TranslationService translationService); }### Answer:
@Test public void testGetStrongMessage() { final DataType dataType = mock(DataType.class); final String dataTypeName = "name"; final String expectedWarningMessage = "*Expected strong message.*"; final WarningMessage warningMessage = new ReferencedDataTypeWarningMessage(translationService); when(dataType.getName()).thenReturn(dataTypeName); when(translationService.format(ReferencedDataTypeWarningMessage_StrongMessage, dataTypeName)).thenReturn(expectedWarningMessage); final String actualWarningMessage = warningMessage.getStrongMessage(dataType); assertEquals(expectedWarningMessage, actualWarningMessage); } |
### Question:
ReferencedDataTypeWarningMessage extends WarningMessage { @Override String getRegularMessage() { return translationService.format(ReferencedDataTypeWarningMessage_RegularMessage); } @Inject ReferencedDataTypeWarningMessage(final TranslationService translationService); }### Answer:
@Test public void testGetRegularMessage() { final String expectedWarningMessage = "Expected regular message."; final WarningMessage warningMessage = new ReferencedDataTypeWarningMessage(translationService); when(translationService.format(ReferencedDataTypeWarningMessage_RegularMessage)).thenReturn(expectedWarningMessage); final String actualWarningMessage = warningMessage.getRegularMessage(); assertEquals(expectedWarningMessage, actualWarningMessage); } |
### Question:
ReferencedDataTypeWarningMessage extends WarningMessage { @Override String getErrorElementSelector(final DataType dataType) { return "[" + UUID_ATTR + "=\"" + dataType.getUUID() + "\"] select"; } @Inject ReferencedDataTypeWarningMessage(final TranslationService translationService); }### Answer:
@Test public void testGetErrorElementSelector() { final DataType dataType = mock(DataType.class); when(dataType.getUUID()).thenReturn("1111-1111-1111-1111"); final String expectedSelector = "[data-row-uuid=\"1111-1111-1111-1111\"] select"; final String actualSelector = new ReferencedDataTypeWarningMessage(translationService).getErrorElementSelector(dataType); assertEquals(expectedSelector, actualSelector); } |
### Question:
DataTypeHasFieldsWarningMessage extends WarningMessage { @Override String getStrongMessage(final DataType dataType) { return translationService.format(DataTypeWithFieldsWarningMessage_StrongMessage); } @Inject DataTypeHasFieldsWarningMessage(final TranslationService translationService); }### Answer:
@Test public void testGetStrongMessage() { final DataType dataType = mock(DataType.class); final String expectedWarningMessage = "*Expected strong message.*"; final WarningMessage warningMessage = new DataTypeHasFieldsWarningMessage(translationService); when(translationService.format(DataTypeWithFieldsWarningMessage_StrongMessage)).thenReturn(expectedWarningMessage); final String actualWarningMessage = warningMessage.getStrongMessage(dataType); assertEquals(expectedWarningMessage, actualWarningMessage); } |
### Question:
DataTypeHasFieldsWarningMessage extends WarningMessage { @Override String getRegularMessage() { return translationService.format(DataTypeWithFieldsWarningMessage_RegularMessage); } @Inject DataTypeHasFieldsWarningMessage(final TranslationService translationService); }### Answer:
@Test public void testGetRegularMessage() { final String expectedWarningMessage = "Expected regular message."; final WarningMessage warningMessage = new DataTypeHasFieldsWarningMessage(translationService); when(translationService.format(DataTypeWithFieldsWarningMessage_RegularMessage)).thenReturn(expectedWarningMessage); final String actualWarningMessage = warningMessage.getRegularMessage(); assertEquals(expectedWarningMessage, actualWarningMessage); } |
### Question:
DataTypeConfirmation { public void ifDataTypeDoesNotHaveLostSubDataTypes(final DataType dataType, final Command onSuccess, final Command onError) { if (hasLostSubDataTypes(dataType)) { flashMessageEvent.fire(dataTypeHasFieldsWarningMessage.getFlashMessage(dataType, onSuccess, onError)); } else { onSuccess.execute(); } } @Inject DataTypeConfirmation(final DataTypeStore dataTypeStore,
final ItemDefinitionStore itemDefinitionStore,
final Event<FlashMessage> flashMessageEvent,
final DataTypeHasFieldsWarningMessage dataTypeHasFieldsWarningMessage,
final ReferencedDataTypeWarningMessage referencedDataTypeWarningMessage,
final TranslationService translationService); void ifDataTypeDoesNotHaveLostSubDataTypes(final DataType dataType,
final Command onSuccess,
final Command onError); void ifIsNotReferencedDataType(final DataType dataType,
final Command onSuccess); }### Answer:
@Test public void testIfDataTypeDoesNotHaveLostSubDataTypesWhenSuccessCallbackIsExecuted() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final Command onSuccess = mock(Command.class); final Command onError = mock(Command.class); final String uuid = "uuid"; when(dataType.getUUID()).thenReturn(uuid); when(dataType.getType()).thenReturn(STRUCTURE); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); confirmation.ifDataTypeDoesNotHaveLostSubDataTypes(dataType, onSuccess, onError); verify(onSuccess).execute(); }
@Test public void testIfDataTypeDoesNotHaveLostSubDataTypesWhenItemDefinitionItemComponentIsEmpty() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<ItemDefinition> itemComponent = singletonList(mock(ItemDefinition.class)); final Command onSuccess = mock(Command.class); final Command onError = mock(Command.class); final String uuid = "uuid"; when(dataType.getUUID()).thenReturn(uuid); when(dataType.getType()).thenReturn(STRUCTURE); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(itemDefinition.getItemComponent()).thenReturn(itemComponent); confirmation.ifDataTypeDoesNotHaveLostSubDataTypes(dataType, onSuccess, onError); verify(onSuccess).execute(); }
@Test public void testIfDataTypeDoesNotHaveLostSubDataTypesWhenItemDefinitionItemComponentIsNotEmpty() { final DataType dataType = mock(DataType.class); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<ItemDefinition> itemComponent = singletonList(mock(ItemDefinition.class)); final Command onSuccess = mock(Command.class); final Command onError = mock(Command.class); final FlashMessage warningMessage = mock(FlashMessage.class); final String uuid = "uuid"; when(dataType.getUUID()).thenReturn(uuid); when(dataType.getType()).thenReturn("tCity"); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(itemDefinition.getItemComponent()).thenReturn(itemComponent); when(dataTypeHasFieldsWarningMessage.getFlashMessage(dataType, onSuccess, onError)).thenReturn(warningMessage); confirmation.ifDataTypeDoesNotHaveLostSubDataTypes(dataType, onSuccess, onError); verify(onSuccess, never()).execute(); verify(flashMessageEvent).fire(warningMessage); } |
### Question:
DataTypeConfirmation { public void ifIsNotReferencedDataType(final DataType dataType, final Command onSuccess) { if (isReferencedByAnotherDataType(dataType)) { flashMessageEvent.fire(referencedDataTypeWarningMessage.getFlashMessage(dataType, onSuccess, () -> { })); } else { onSuccess.execute(); } } @Inject DataTypeConfirmation(final DataTypeStore dataTypeStore,
final ItemDefinitionStore itemDefinitionStore,
final Event<FlashMessage> flashMessageEvent,
final DataTypeHasFieldsWarningMessage dataTypeHasFieldsWarningMessage,
final ReferencedDataTypeWarningMessage referencedDataTypeWarningMessage,
final TranslationService translationService); void ifDataTypeDoesNotHaveLostSubDataTypes(final DataType dataType,
final Command onSuccess,
final Command onError); void ifIsNotReferencedDataType(final DataType dataType,
final Command onSuccess); }### Answer:
@Test public void testIfIsNotReferencedDataTypeWhenCallbackIsExecuted() { final DataType dataType = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final List<DataType> allDataTypes = asList(dataType1, dataType2); final Command callback = mock(Command.class); final String tCity = "tCity"; final String tPerson = "tPerson"; final String tDocument = "tDocument"; when(dataType.getName()).thenReturn(tCity); when(dataType1.getType()).thenReturn(tDocument); when(dataType2.getType()).thenReturn(tPerson); when(dataTypeStore.all()).thenReturn(allDataTypes); confirmation.ifIsNotReferencedDataType(dataType, callback); verify(callback).execute(); }
@Test public void testIfIsNotReferencedDataTypeWhenCallbackIsNotExecuted() { final DataType dataType = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final List<DataType> allDataTypes = asList(dataType1, dataType2); final FlashMessage warningMessage = mock(FlashMessage.class); final Command onSuccess = mock(Command.class); final String tCity = "tCity"; final String tPerson = "tPerson"; when(dataType.getName()).thenReturn(tCity); when(dataType1.getType()).thenReturn(tCity); when(dataType2.getType()).thenReturn(tPerson); when(referencedDataTypeWarningMessage.getFlashMessage(eq(dataType), eq(onSuccess), any())).thenReturn(warningMessage); when(dataTypeStore.all()).thenReturn(allDataTypes); confirmation.ifIsNotReferencedDataType(dataType, onSuccess); verify(onSuccess, never()).execute(); verify(flashMessageEvent).fire(warningMessage); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { @Override public void setupDropdown() { setupDropdownItems(); setupSelectPicker(); hideSelectPicker(); setupSelectPickerOnChangeHandler(); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testSetupDropdown() { doCallRealMethod().when(view).setupDropdown(); doNothing().when(view).setupDropdownItems(); doNothing().when(view).setupSelectPicker(); doNothing().when(view).hideSelectPicker(); doNothing().when(view).setupSelectPickerOnChangeHandler(); view.setupDropdown(); verify(view).setupDropdownItems(); verify(view).setupSelectPicker(); verify(view).hideSelectPicker(); verify(view).setupSelectPickerOnChangeHandler(); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { void setupDropdownItems() { RemoveHelper.removeChildren(typeSelect); typeSelect.appendChild(makeOptionGroup(defaultTitle(), presenter.getDefaultDataTypes(), DataType::getType)); typeSelect.appendChild(makeOptionGroup(customTitle(), presenter.getCustomDataTypes(), DataType::getName)); typeSelect.appendChild(makeOptionStructureGroup()); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testSetupDropdownItems() { final HTMLOptGroupElement groupElementCustom = mock(HTMLOptGroupElement.class); final HTMLOptGroupElement groupElementDefault = mock(HTMLOptGroupElement.class); final List<DataType> defaultDataTypes = new ArrayList<>(); final List<DataType> customDataTypes = new ArrayList<>(); final Element element = mock(Element.class); when(translationService.format(DataTypeSelectView_DefaultTitle)).thenReturn("Default"); when(translationService.format(DataTypeSelectView_CustomTitle)).thenReturn("Custom"); when(presenter.getDefaultDataTypes()).thenReturn(defaultDataTypes); when(presenter.getCustomDataTypes()).thenReturn(customDataTypes); doReturn(groupElementCustom).when(view).makeOptionGroup(eq("Default"), eq(defaultDataTypes), any()); doReturn(groupElementDefault).when(view).makeOptionGroup(eq("Custom"), eq(customDataTypes), any()); typeSelect.firstChild = element; when(typeSelect.removeChild(element)).then(a -> { typeSelect.firstChild = null; return element; }); view.setupDropdownItems(); verify(typeSelect).removeChild(element); verify(typeSelect).appendChild(groupElementCustom); verify(typeSelect).appendChild(groupElementDefault); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { HTMLOptGroupElement makeOptionGroup(final String groupTitle, final List<DataType> dataTypes, final Function<DataType, String> dataTypeConsumer) { final HTMLOptGroupElement optionGroup = makeHTMLOptGroupElement(); optionGroup.label = groupTitle; dataTypes.stream() .forEach(dataType -> { final HTMLOptionElement option = makeOption(dataType, dataTypeConsumer); optionGroup.appendChild(option); }); return optionGroup; } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testMakeOptionGroup() { final String dataTypeName = "name"; final String groupTitle = "Title"; final DataType dataType = makeDataType(dataTypeName); final List<DataType> dataTypes = Collections.singletonList(dataType); final HTMLOptGroupElement expectedGroupElement = mock(HTMLOptGroupElement.class); final HTMLOptionElement optionElement = mock(HTMLOptionElement.class); doReturn(expectedGroupElement).when(view).makeHTMLOptGroupElement(); doReturn(optionElement).when(view).makeOption(eq(dataType), any(Function.class)); final HTMLOptGroupElement actualGroupElement = view.makeOptionGroup(groupTitle, dataTypes, DataType::getName); verify(expectedGroupElement).appendChild(optionElement); assertEquals(expectedGroupElement, actualGroupElement); assertEquals(groupTitle, actualGroupElement.label); } |
### Question:
DMNGridWidgetDnDMouseUpHandler extends GridWidgetDnDMouseUpHandler { @Override public void onNodeMouseUp(final NodeMouseUpEvent event) { if (state.getOperation() == GridWidgetDnDHandlersState.GridWidgetHandlersOperation.COLUMN_RESIZE) { final GridWidget gridWidget = state.getActiveGridWidget(); final List<GridColumn<?>> gridColumns = state.getActiveGridColumns(); if (isBaseGrid(gridWidget) && isSingleDMNColumn(gridColumns)) { final BaseGrid uiGridWidget = (BaseGrid) gridWidget; final DMNGridColumn uiColumn = (DMNGridColumn) gridColumns.get(0); uiGridWidget.registerColumnResizeCompleted(uiColumn, state.getEventInitialColumnWidth()); } } super.onNodeMouseUp(event); } DMNGridWidgetDnDMouseUpHandler(final GridLayer layer,
final GridWidgetDnDHandlersState state); @Override void onNodeMouseUp(final NodeMouseUpEvent event); }### Answer:
@Test public void testColumnResize() { state.setOperation(GridWidgetHandlersOperation.COLUMN_RESIZE); state.setActiveGridWidget(activeGridWidget); state.setActiveGridColumns(Collections.singletonList(activeGridColumn)); state.setEventInitialColumnWidth(INITIAL_WIDTH); handler.onNodeMouseUp(event); verify(activeGridWidget).registerColumnResizeCompleted(activeGridColumn, INITIAL_WIDTH); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { HTMLOptionElement makeOption(final DataType dataType, final Function<DataType, String> dataTypeConsumer) { final String optionValue = dataTypeConsumer.apply(dataType); final HTMLOptionElement option = makeHTMLOptionElement(); option.text = optionValue; option.value = optionValue; return option; } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testMakeOption() { final String value = "value"; final DataType dataType = makeDataType(value); final HTMLOptionElement htmlOptionElement = mock(HTMLOptionElement.class); doReturn(htmlOptionElement).when(view).makeHTMLOptionElement(); final HTMLOptionElement option = view.makeOption(dataType, DataType::getName); assertEquals(value, option.text); assertEquals(value, option.value); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { @Override public void setDataType(final DataType dataType) { final String type = dataType.getType(); typeText.textContent = "(" + type + ")"; value = type; } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testSetDataType() { final String expectedType = "type"; final DataType dataType = makeDataType(expectedType); final String expectedTypeText = "(type)"; view.setDataType(dataType); final String actualType = view.getValue(); final String actualTypeText = typeText.textContent; assertEquals(expectedType, actualType); assertEquals(expectedTypeText, actualTypeText); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { void setPickerValue(final String value) { setPickerValue(getSelectPicker(), value); this.value = value; } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testSetPickerValue() { final Element element = mock(Element.class); final String value = "value"; doReturn(element).when(view).getSelectPicker(); view.setPickerValue(value); verify(view).setPickerValue(element, value); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { void setupSelectPickerOnChangeHandler() { setupOnChangeHandler(getSelectPicker()); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testSetupSelectPickerOnChangeHandler() { final Element element = mock(Element.class); doReturn(element).when(view).getSelectPicker(); view.setupSelectPickerOnChangeHandler(); verify(view).setupOnChangeHandler(element); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { void hideSelectPicker() { triggerPickerAction(getSelectPicker(), "destroy"); triggerPickerAction(getSelectPicker(), "hide"); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testHideSelectPicker() { final Element element = mock(Element.class); doReturn(element).when(view).getSelectPicker(); view.hideSelectPicker(); verify(view).triggerPickerAction(element, "destroy"); verify(view).triggerPickerAction(element, "hide"); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { void showSelectPicker() { triggerPickerAction(getSelectPicker(), "show"); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testShowSelectPicker() { final Element element = mock(Element.class); doReturn(element).when(view).getSelectPicker(); view.showSelectPicker(); verify(view).triggerPickerAction(element, "show"); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { void setupSelectPicker() { triggerPickerAction(getSelectPicker(), "refresh"); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testSetupSelectPicker() { final Element element = mock(Element.class); doReturn(element).when(view).getSelectPicker(); view.setupSelectPicker(); verify(view).triggerPickerAction(element, "refresh"); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { Element getSelectPicker() { return getElement().querySelector("[data-field='type-select']"); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testGetSelectPicker() { final HTMLElement element = mock(HTMLElement.class); final HTMLElement expectedSelect = mock(HTMLElement.class); doReturn(element).when(view).getElement(); when(element.querySelector("[data-field='type-select']")).thenReturn(expectedSelect); final Element actualSelect = view.getSelectPicker(); assertEquals(expectedSelect, actualSelect); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { @Override public void enableEditMode() { hide(typeText); showSelectPicker(); setPickerValue(presenter.getDataType().getType()); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testEnableEditMode() { final String type = "type"; final DataType dataType = makeDataType(type); doNothing().when(view).showSelectPicker(); doNothing().when(view).setPickerValue(anyString()); when(presenter.getDataType()).thenReturn(dataType); typeText.classList = mock(DOMTokenList.class); view.enableEditMode(); verify(typeText.classList).add(HIDDEN_CSS_CLASS); verify(view).showSelectPicker(); verify(view).setPickerValue(type); } |
### Question:
DataTypeSelectView implements DataTypeSelect.View { @Override public void disableEditMode() { typeText.textContent = "(" + presenter.getDataType().getType() + ")"; hideSelectPicker(); show(typeText); } @Inject DataTypeSelectView(final HTMLDivElement typeText,
final HTMLSelectElement typeSelect,
final HTMLOptGroupElement typeSelectOptGroup,
final HTMLOptionElement typeSelectOption,
final HTMLOptGroupElement typeSelectStructureOptGroup,
final TranslationService translationService); @Override void init(final DataTypeSelect presenter); @Override void setupDropdown(); @Override void enableEditMode(); @Override void disableEditMode(); @Override void setDataType(final DataType dataType); void onSelectChange(final JQuerySelectPickerEvent event); @Override String getValue(); }### Answer:
@Test public void testDisableEditMode() { final String type = "type"; final String expectedTypeText = "(type)"; final DataType dataType = makeDataType(type); doNothing().when(view).hideSelectPicker(); when(presenter.getDataType()).thenReturn(dataType); typeText.classList = mock(DOMTokenList.class); view.disableEditMode(); assertEquals(expectedTypeText, typeText.textContent); verify(typeText.classList).remove(HIDDEN_CSS_CLASS); verify(view).hideSelectPicker(); } |
### Question:
DMNGridPanelContainer extends SimplePanel implements RequiresResize { @Override public void setWidget(final IsWidget w) { if (w instanceof RequiresResize) { resizableContent = Optional.of((RequiresResize) w); } super.setWidget(w); } @Override void setWidget(final IsWidget w); @Override void setWidget(final Widget w); @Override void onResize(); }### Answer:
@Test public void testSetWidgetNotResizableAndResize() { final Widget widget = mock(Widget.class); container.setWidget(widget); verifyNotResizableInteractions(widget); }
@Test public void testSetIsWidgetNotResizableAndResize() { final IsWidget widget = mock(IsWidget.class); container.setWidget(widget); verifyNotResizableInteractions(widget); }
@Test public void testSetWidgetIsResizableAndResize() { final ResizeComposite widget = mock(ResizeComposite.class); container.setWidget(widget); verifyResizableInteractions(widget); }
@Test public void testSetWidgetIsResizableAndResizeWithZeroWidth() { when(containerParentElement.getOffsetWidth()).thenReturn(0); final ResizeComposite widget = mock(ResizeComposite.class); container.setWidget(widget); verifyResizableInteractionsWithZeroDimension(widget); }
@Test public void testSetWidgetIsResizableAndResizeWithZeroHeight() { when(containerParentElement.getOffsetHeight()).thenReturn(0); final ResizeComposite widget = mock(ResizeComposite.class); container.setWidget(widget); verifyResizableInteractionsWithZeroDimension(widget); } |
### Question:
DataTypeListItem { @PostConstruct void setup() { view.init(this); canNotHaveConstraintTypes = new String[]{ BOOLEAN.getName(), dataTypeManager.structure(), CONTEXT.getName() }; } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetup() { verify(view).init(listItem); } |
### Question:
DataTypeListItem { HTMLElement getContentElement() { return view.getElement(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testGetContentElement() { final HTMLElement expectedElement = mock(HTMLElement.class); when(view.getElement()).thenReturn(expectedElement); HTMLElement actualElement = listItem.getContentElement(); assertEquals(expectedElement, actualElement); } |
### Question:
DataTypeListItem { void setupDataType(final DataType dataType, final int level) { this.dataType = dataType; this.level = level; setupDragAndDropComponent(); setupSelectComponent(); setupListComponent(); setupConstraintComponent(); setupView(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetupDataType() { final DataType expectedDataType = this.dataType; final int expectedLevel = 1; doNothing().when(listItem).setupDragAndDropComponent(); doNothing().when(listItem).setupView(); listItem.setupDataType(expectedDataType, expectedLevel); final InOrder inOrder = inOrder(listItem); inOrder.verify(listItem).setupDragAndDropComponent(); inOrder.verify(listItem).setupSelectComponent(); inOrder.verify(listItem).setupListComponent(); inOrder.verify(listItem).setupConstraintComponent(); inOrder.verify(listItem).setupView(); assertEquals(expectedDataType, listItem.getDataType()); assertEquals(expectedLevel, listItem.getLevel()); } |
### Question:
DataTypeListItem { void setupDragAndDropComponent() { final DNDListComponent dragAndDropComponent = getDNDListComponent(); this.dragAndDropElement = dragAndDropComponent.registerNewItem(getContentElement()); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetupDragAndDropComponent() { final DNDListComponent dragAndDropComponent = mock(DNDListComponent.class); final HTMLElement htmlElement = mock(HTMLElement.class); final HTMLElement expectedElement = mock(HTMLElement.class); when(dataTypeList.getDNDListComponent()).thenReturn(dragAndDropComponent); when(listItem.getContentElement()).thenReturn(htmlElement); when(dragAndDropComponent.registerNewItem(htmlElement)).thenReturn(expectedElement); listItem.setupDragAndDropComponent(); final HTMLElement actualElement = listItem.getDragAndDropElement(); assertEquals(expectedElement, actualElement); } |
### Question:
DataTypeListItem { void setupConstraintComponent() { dataTypeConstraintComponent.init(this); refreshConstraintComponent(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetupConstraintComponent() { final DataType dataType = mock(DataType.class); doReturn(dataType).when(listItem).getDataType(); listItem.setupConstraintComponent(); verify(dataTypeConstraintComponent).init(listItem); verify(listItem).refreshConstraintComponent(); } |
### Question:
DataTypeListItem { void setupSelectComponent() { dataTypeSelectComponent.init(this, getDataType()); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetupSelectComponent() { final DataType dataType = mock(DataType.class); doReturn(dataType).when(listItem).getDataType(); listItem.setupSelectComponent(); verify(dataTypeSelectComponent).init(listItem, dataType); } |
### Question:
DataTypeListItem { void setupView() { view.setupSelectComponent(dataTypeSelectComponent); view.setupConstraintComponent(dataTypeConstraintComponent); view.setupListComponent(dataTypeListComponent); view.setDataType(getDataType()); setupIndentationLevel(); hideTooltips(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetupView() { final DataType dataType = mock(DataType.class); when(listItem.getDataType()).thenReturn(dataType); doNothing().when(listItem).setupIndentationLevel(); doNothing().when(listItem).hideTooltips(); listItem.setupView(); verify(view).setupSelectComponent(dataTypeSelectComponent); verify(view).setupConstraintComponent(dataTypeConstraintComponent); verify(view).setupListComponent(dataTypeListComponent); verify(view).setDataType(dataType); verify(listItem).setupIndentationLevel(); verify(listItem).hideTooltips(); } |
### Question:
DataTypeListItem { public void collapse() { view.collapse(); dataTypeList.highlightLevel(getDragAndDropElement()); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testCollapse() { final HTMLElement dragAndDropElement = mock(HTMLElement.class); doReturn(dragAndDropElement).when(listItem).getDragAndDropElement(); listItem.collapse(); verify(view).collapse(); verify(dataTypeList).highlightLevel(dragAndDropElement); } |
### Question:
DataTypeListItem { public void expand() { view.expand(); dataTypeList.highlightLevel(getDragAndDropElement()); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testExpand() { final HTMLElement dragAndDropElement = mock(HTMLElement.class); doReturn(dragAndDropElement).when(listItem).getDragAndDropElement(); listItem.expand(); verify(view).expand(); verify(dataTypeList).highlightLevel(dragAndDropElement); } |
### Question:
DataTypeListItem { void refreshSubItems(final List<DataType> dataTypes, final boolean enableFocusMode) { dataTypeList.refreshSubItemsFromListItem(this, dataTypes); dataTypeList.refreshDragAndDropList(); if (enableFocusMode) { view.enableFocusMode(); } view.toggleArrow(!dataTypes.isEmpty()); dataTypes.forEach(dataTypeList::highlightLevel); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testRefreshSubItems() { final DataType dataType = mock(DataType.class); final List<DataType> dataTypes = singletonList(dataType); listItem.refreshSubItems(dataTypes, true); verify(dataTypeList).refreshSubItemsFromListItem(listItem, dataTypes); verify(listItem, never()).expandOrCollapseSubTypes(); verify(view).enableFocusMode(); verify(view).toggleArrow(anyBoolean()); verify(dataTypeList).highlightLevel(dataType); } |
### Question:
DataTypeListItem { public void enableEditMode() { if (view.isOnFocusMode()) { return; } oldName = getDataType().getName(); oldType = getDataType().getType(); oldConstraint = getDataType().getConstraint(); oldIsList = getDataType().isList(); oldConstraintType = getDataType().getConstraintType(); view.showSaveButton(); view.showDataTypeNameInput(); view.showListContainer(); view.hideListYesLabel(); view.enableFocusMode(); dataTypeSelectComponent.enableEditMode(); dataTypeConstraintComponent.enableEditMode(); editModeToggleEvent.fire(new DataTypeEditModeToggleEvent(true, this)); dataTypeList.fireOnDataTypeListItemUpdateCallback(this); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testEnableEditMode() { final DataType dataType = mock(DataType.class); final String expectedName = "name"; final String expectedType = "type"; final String expectedConstraint = "constraint"; final boolean expectedIsList = true; final String expectedConstraintType = ""; doReturn(dataType).when(listItem).getDataType(); when(dataType.getName()).thenReturn(expectedName); when(dataType.getType()).thenReturn(expectedType); when(dataType.getConstraint()).thenReturn(expectedConstraint); when(dataType.isList()).thenReturn(expectedIsList); when(view.isOnFocusMode()).thenReturn(false); listItem.enableEditMode(); assertEquals(expectedName, listItem.getOldName()); assertEquals(expectedType, listItem.getOldType()); assertEquals(expectedConstraint, listItem.getOldConstraint()); assertEquals(expectedIsList, listItem.getOldIsList()); assertEquals(expectedConstraintType, listItem.getOldConstraintType()); verify(view).showSaveButton(); verify(view).showDataTypeNameInput(); verify(view).enableFocusMode(); verify(view).hideListYesLabel(); verify(view).showListContainer(); verify(dataTypeSelectComponent).enableEditMode(); verify(dataTypeConstraintComponent).enableEditMode(); verify(editModeToggleEvent).fire(eventArgumentCaptor.capture()); verify(dataTypeList).fireOnDataTypeListItemUpdateCallback(listItem); assertTrue(eventArgumentCaptor.getValue().isEditModeEnabled()); }
@Test public void testEnableEditModeWhenDataTypeListItemIsAlreadyOnEditMode() { when(view.isOnFocusMode()).thenReturn(true); listItem.enableEditMode(); verify(view, never()).showSaveButton(); verify(view, never()).showDataTypeNameInput(); verify(view, never()).enableFocusMode(); verify(view, never()).hideListYesLabel(); verify(view, never()).showListContainer(); verify(dataTypeSelectComponent, never()).enableEditMode(); verify(dataTypeConstraintComponent, never()).enableEditMode(); verify(editModeToggleEvent, never()).fire(any()); verify(dataTypeList, never()).fireOnDataTypeListItemUpdateCallback(any(DataTypeListItem.class)); } |
### Question:
DataTypeListItem { public void disableEditMode() { if (view.isOnFocusMode()) { discardNewDataType(); closeEditMode(); hideTooltips(); } } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDisableEditMode() { when(view.isOnFocusMode()).thenReturn(true); doNothing().when(listItem).discardNewDataType(); doNothing().when(listItem).closeEditMode(); doNothing().when(listItem).hideTooltips(); listItem.disableEditMode(); verify(listItem).discardNewDataType(); verify(listItem).closeEditMode(); verify(listItem).hideTooltips(); } |
### Question:
DataTypeListItem { Command doDisableEditMode() { return this::disableEditMode; } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDoDisableEditMode() { doNothing().when(listItem).disableEditMode(); listItem.doDisableEditMode().execute(); verify(listItem).disableEditMode(); } |
### Question:
DataTypeListItem { Command doValidateDataTypeNameAndSave(final DataType dataType) { return () -> nameFormatValidator.ifIsValid(dataType, doSaveAndCloseEditMode(dataType)); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDoValidateDataTypeNameAndSave() { final DataType dataType = spy(makeDataType()); final Command saveAndCloseEditMode = mock(Command.class); doReturn(saveAndCloseEditMode).when(listItem).doSaveAndCloseEditMode(dataType); listItem.doValidateDataTypeNameAndSave(dataType).execute(); verify(nameFormatValidator).ifIsValid(dataType, saveAndCloseEditMode); } |
### Question:
DataTypeListItem { Command doSaveAndCloseEditMode(final DataType dataType) { return () -> { final String referenceDataTypeHash = dataTypeList.calculateParentHash(dataType); dataTypeList.refreshItemsByUpdatedDataTypes(persist(dataType)); closeEditMode(); final String newDataTypeHash = getNewDataTypeHash(dataType, referenceDataTypeHash); dataTypeList.fireOnDataTypeListItemUpdateCallback(newDataTypeHash); insertNewFieldIfDataTypeIsStructure(newDataTypeHash); fireDataChangedEvent(); }; } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDoSaveAndCloseEditMode() { final DataType dataType = spy(makeDataType()); final List<DataType> updatedDataTypes = singletonList(makeDataType()); final String referenceDataTypeHash = "referenceDataTypeHash"; final String newDataTypeHash = "newDataTypeHash"; doReturn(updatedDataTypes).when(listItem).persist(dataType); doReturn(dataType).when(listItem).getDataType(); doReturn(newDataTypeHash).when(listItem).getNewDataTypeHash(dataType, referenceDataTypeHash); doNothing().when(listItem).insertNewFieldIfDataTypeIsStructure(newDataTypeHash); when(dataTypeList.calculateParentHash(dataType)).thenReturn(referenceDataTypeHash); listItem.doSaveAndCloseEditMode(dataType).execute(); verify(dataTypeList).refreshItemsByUpdatedDataTypes(updatedDataTypes); verify(listItem).closeEditMode(); verify(dataTypeList).fireOnDataTypeListItemUpdateCallback(newDataTypeHash); verify(listItem).insertNewFieldIfDataTypeIsStructure(newDataTypeHash); verify(listItem).fireDataChangedEvent(); } |
### Question:
DataTypeListItem { List<DataType> persist(final DataType dataType) { return dataTypeManager .from(dataType) .withSubDataTypes(dataTypeSelectComponent.getSubDataTypes()) .get() .update(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testPersist() { final String uuid = "uuid"; final DataType dataType = spy(makeDataType()); final ItemDefinition itemDefinition = mock(ItemDefinition.class); final List<DataType> subDataTypes = singletonList(makeDataType()); final List<DataType> affectedDataTypes = emptyList(); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(dataTypeSelectComponent.getSubDataTypes()).thenReturn(subDataTypes); doReturn(uuid).when(dataType).getUUID(); doReturn(affectedDataTypes).when(dataType).update(); listItem.persist(dataType); final InOrder inOrder = inOrder(dataTypeManager, dataType); inOrder.verify(dataTypeManager).from(dataType); inOrder.verify(dataTypeManager).withSubDataTypes(subDataTypes); inOrder.verify(dataTypeManager).get(); inOrder.verify(dataType).update(); } |
### Question:
DataTypeListItem { void discardNewDataType() { final DataType oldDataType = discardDataTypeProperties(); view.setDataType(oldDataType); setupListComponent(); setupSelectComponent(); setupConstraintComponent(); setupIndentationLevel(); refreshSubItems(oldDataType.getSubDataTypes(), true); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDiscardNewDataType() { final DataType dataType = spy(makeDataType()); final List<DataType> subDataTypes = Collections.emptyList(); doNothing().when(listItem).setupSelectComponent(); doNothing().when(listItem).setupListComponent(); doNothing().when(listItem).setupIndentationLevel(); doNothing().when(listItem).refreshSubItems(subDataTypes, true); doReturn(subDataTypes).when(dataType).getSubDataTypes(); doReturn(dataType).when(listItem).discardDataTypeProperties(); listItem.discardNewDataType(); verify(view).setDataType(dataType); verify(listItem).setupListComponent(); verify(listItem).setupSelectComponent(); verify(listItem).setupConstraintComponent(); verify(listItem).refreshSubItems(subDataTypes, true); verify(listItem).setupIndentationLevel(); } |
### Question:
DataTypeListItem { DataType discardDataTypeProperties() { return dataTypeManager .withDataType(getDataType()) .withName(getOldName()) .withType(getOldType()) .withConstraint(getOldConstraint()) .withConstraintType(getOldConstraintType()) .asList(getOldIsList()) .get(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDiscardDataTypeProperties() { final DataType dataType = spy(makeDataType()); final String expectedName = "name"; final String expectedType = "type"; final String expectedConstraint = "constraint"; final String expectedConstraintType = "enumeration"; final boolean expectedIsList = true; doReturn(dataType).when(listItem).getDataType(); doReturn(expectedName).when(listItem).getOldName(); doReturn(expectedType).when(listItem).getOldType(); doReturn(expectedConstraint).when(listItem).getOldConstraint(); doReturn(expectedIsList).when(listItem).getOldIsList(); doReturn(expectedConstraintType).when(listItem).getOldConstraintType(); listItem.discardDataTypeProperties(); assertEquals(expectedName, dataType.getName()); assertEquals(expectedType, dataType.getType()); assertEquals(expectedConstraint, dataType.getConstraint()); assertEquals(expectedIsList, dataType.isList()); assertEquals(expectedConstraintType, dataType.getConstraintType().value()); } |
### Question:
DataTypeListItem { void closeEditMode() { view.hideDataTypeNameInput(); view.hideListContainer(); view.showEditButton(); view.disableFocusMode(); refreshListYesLabel(); dataTypeSelectComponent.disableEditMode(); dataTypeConstraintComponent.disableEditMode(); editModeToggleEvent.fire(new DataTypeEditModeToggleEvent(false, this)); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testCloseEditMode() { doReturn(dataType).when(listItem).getDataType(); listItem.closeEditMode(); verify(view).showEditButton(); verify(view).hideDataTypeNameInput(); verify(view).disableFocusMode(); verify(view).hideListContainer(); verify(listItem).refreshListYesLabel(); verify(dataTypeSelectComponent).disableEditMode(); verify(dataTypeConstraintComponent).disableEditMode(); verify(editModeToggleEvent).fire(eventArgumentCaptor.capture()); assertFalse(eventArgumentCaptor.getValue().isEditModeEnabled()); } |
### Question:
DataTypeListItem { DataType updateProperties(final DataType dataType) { return dataTypeManager .from(dataType) .withName(NameUtils.normaliseName(getName())) .withType(getType()) .withConstraint(getConstraint()) .withConstraintType(getConstraintType()) .asList(isList()) .get(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testUpdateProperties() { final DataType dataType = spy(makeDataType()); final String uuid = "uuid"; final String expectedName = "name"; final String expectedType = "type"; final String expectedConstraint = "constraint"; final boolean expectedList = true; final ItemDefinition itemDefinition = mock(ItemDefinition.class); when(dataType.getUUID()).thenReturn(uuid); when(itemDefinitionStore.get(uuid)).thenReturn(itemDefinition); when(view.getName()).thenReturn(expectedName); when(dataTypeSelectComponent.getValue()).thenReturn(expectedType); when(dataTypeConstraintComponent.getValue()).thenReturn(expectedConstraint); when(dataTypeListComponent.getValue()).thenReturn(expectedList); when(dataTypeManager.get()).thenReturn(dataType); final DataType updatedDataType = listItem.updateProperties(dataType); assertEquals(expectedName, updatedDataType.getName()); assertEquals(expectedType, updatedDataType.getType()); assertEquals(expectedConstraint, updatedDataType.getConstraint()); assertEquals(expectedList, updatedDataType.isList()); } |
### Question:
DataTypeListItem { void refresh() { dataTypeSelectComponent.refresh(); dataTypeSelectComponent.init(this, getDataType()); dataTypeConstraintComponent.refreshView(); view.setName(getDataType().getName()); setupListComponent(); setupConstraintComponent(); hideTooltips(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testRefresh() { final DataType dataType = spy(makeDataType()); final String expectedConstraint = "constraint"; final String expectedName = "name"; doReturn(expectedConstraint).when(dataType).getConstraint(); doReturn(expectedName).when(dataType).getName(); doReturn(dataType).when(listItem).getDataType(); doNothing().when(listItem).hideTooltips(); listItem.refresh(); verify(dataTypeSelectComponent).refresh(); verify(dataTypeSelectComponent).init(listItem, dataType); verify(dataTypeConstraintComponent).refreshView(); verify(view).setName(expectedName); verify(listItem).setupListComponent(); verify(listItem).setupConstraintComponent(); verify(listItem).hideTooltips(); } |
### Question:
DataTypeListItem { public void remove() { confirmation.ifIsNotReferencedDataType(getDataType(), removeItem()); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testRemove() { final DataType dataType = mock(DataType.class); final Command command = mock(Command.class); doReturn(dataType).when(listItem).getDataType(); doReturn(command).when(listItem).removeItem(); listItem.remove(); verify(confirmation).ifIsNotReferencedDataType(dataType, command); } |
### Question:
DataTypeListItem { public Command removeItem() { return () -> { dataTypeList.disableEditModeForChildren(this); destroyWithDependentTypes(); }; } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testRemoveItem() { final Command command = listItem.removeItem(); doNothing().when(listItem).destroyWithDependentTypes(); command.execute(); verify(dataTypeList).disableEditModeForChildren(listItem); verify(listItem).destroyWithDependentTypes(); } |
### Question:
DataTypeListItem { public Command destroy() { return this::destroyWithDependentTypes; } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDestroy() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final DataType dataType2 = mock(DataType.class); final DataType dataType3 = mock(DataType.class); final List<DataType> destroyedDataTypes = new ArrayList<>(asList(dataType0, dataType1, dataType2, dataType3)); final List<DataType> removedDataTypes = asList(dataType1, dataType2); doReturn(destroyedDataTypes).when(dataType).destroy(); doReturn(removedDataTypes).when(listItem).removeTopLevelDataTypes(destroyedDataTypes); doReturn(dataType).when(listItem).getDataType(); doNothing().when(listItem).hideTooltips(); listItem.destroy().execute(); verify(dataTypeList).refreshItemsByUpdatedDataTypes(asList(dataType0, dataType3)); verify(listItem).fireDataChangedEvent(); verify(listItem).hideTooltips(); } |
### Question:
DataTypeListItem { public void destroyWithDependentTypes() { final List<DataType> destroyedDataTypes = getDataType().destroy(); destroy(destroyedDataTypes, true); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDestroyWithDependentTypes() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final DataType dataType1 = mock(DataType.class); final List<DataType> removedDataTypes = asList(dataType0, dataType1); when(dataType.destroy()).thenReturn(removedDataTypes); doReturn(dataType).when(listItem).getDataType(); doNothing().when(listItem).destroy(any(), eq(true)); listItem.destroyWithDependentTypes(); verify(listItem).destroy(removedDataTypes, true); } |
### Question:
DataTypeListItem { public void destroyWithoutDependentTypes() { final List<DataType> destroyedDataTypes = getDataType().destroyWithoutDependentTypes(); destroy(destroyedDataTypes, false); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testDestroyWithoutDependentTypes() { final DataType dataType = mock(DataType.class); final DataType dataType0 = mock(DataType.class); final List<DataType> removedDataTypes = asList(dataType0); when(dataType.destroyWithoutDependentTypes()).thenReturn(removedDataTypes); doReturn(dataType).when(listItem).getDataType(); doNothing().when(listItem).destroy(any(), eq(false)); listItem.destroyWithoutDependentTypes(); verify(listItem).destroy(removedDataTypes, false); } |
### Question:
DataTypeListItem { public void insertNestedField() { final DataType newDataType = newDataType(); final String referenceDataTypeHash = dataTypeList.calculateHash(getDataType()); insertNestedField(newDataType); enableEditModeAndUpdateCallbacks(getNewDataTypeHash(newDataType, referenceDataTypeHash)); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testInsertNestedField() { final DataType newDataType = mock(DataType.class); final DataType reference = mock(DataType.class); final DataTypeListItem referenceItem = mock(DataTypeListItem.class); final List<DataType> updatedDataTypes = asList(mock(DataType.class), mock(DataType.class)); final String referenceDataTypeHash = "tDataType.id"; final String newDataTypeHash = "tDataType.id.value"; when(newDataType.create(reference, NESTED)).thenReturn(updatedDataTypes); when(dataTypeList.calculateHash(reference)).thenReturn(referenceDataTypeHash); when(dataTypeList.findItemByDataTypeHash(referenceDataTypeHash)).thenReturn(Optional.of(referenceItem)); doReturn(newDataTypeHash).when(listItem).getNewDataTypeHash(newDataType, referenceDataTypeHash); doReturn(dataTypeManager).when(dataTypeManager).fromNew(); doReturn(newDataType).when(dataTypeManager).get(); doReturn(reference).when(listItem).getDataType(); listItem.insertNestedField(); verify(dataTypeList).refreshItemsByUpdatedDataTypes(updatedDataTypes); verify(listItem).enableEditModeAndUpdateCallbacks(newDataTypeHash); verify(referenceItem).expand(); } |
### Question:
DataTypeListItem { void refreshConstraintComponent() { if (canNotHaveConstraint()) { dataTypeConstraintComponent.disable(); } else { dataTypeConstraintComponent.enable(); } } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testRefreshConstraintComponentWhenSelectedTypeIsStructure() { when(dataTypeSelectComponent.getValue()).thenReturn(structure); listItem.refreshConstraintComponent(); verify(dataTypeConstraintComponent).disable(); }
@Test public void testRefreshConstraintComponentWhenSelectedTypeIsAList() { when(dataTypeListComponent.getValue()).thenReturn(true); listItem.refreshConstraintComponent(); verify(dataTypeConstraintComponent).disable(); } |
### Question:
DataTypeListItem { void enableEditModeAndUpdateCallbacks(final String dataTypeHash) { dataTypeList.enableEditMode(dataTypeHash); dataTypeList.fireOnDataTypeListItemUpdateCallback(dataTypeHash); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testEnableEditModeAndUpdateCallbacks() { final String dataTypeHash = "dataTypeHash"; listItem.enableEditModeAndUpdateCallbacks(dataTypeHash); verify(dataTypeList).enableEditMode(dataTypeHash); verify(dataTypeList).fireOnDataTypeListItemUpdateCallback(dataTypeHash); } |
### Question:
DataTypeListItem { void refreshItemsCSSAndHTMLPosition() { dataTypeList.refreshItemsCSSAndHTMLPosition(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testRefreshItemsCSSAndHTMLPosition() { listItem.refreshItemsCSSAndHTMLPosition(); verify(dataTypeList).refreshItemsCSSAndHTMLPosition(); } |
### Question:
DataTypeListItem { void setPositionX(final Element element, final double positionX) { getDNDListComponent().setPositionX(element, positionX); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetPositionX() { final DNDListComponent dndListComponent = mock(DNDListComponent.class); final Element element = mock(Element.class); final int positionX = 2; when(dataTypeList.getDNDListComponent()).thenReturn(dndListComponent); listItem.setPositionX(element, positionX); verify(dndListComponent).setPositionX(element, positionX); } |
### Question:
DataTypeListItem { void setPositionY(final Element element, final double positionY) { getDNDListComponent().setPositionY(element, positionY); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetPositionY() { final DNDListComponent dndListComponent = mock(DNDListComponent.class); final Element element = mock(Element.class); final int positionY = 2; when(dataTypeList.getDNDListComponent()).thenReturn(dndListComponent); listItem.setPositionY(element, positionY); verify(dndListComponent).setPositionY(element, positionY); } |
### Question:
DataTypeListItem { int getPositionY(final Element element) { return getDNDListComponent().getPositionY(element); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testGetPositionY() { final DNDListComponent dndListComponent = mock(DNDListComponent.class); final Element element = mock(Element.class); final Integer expectedPositionY = 2; when(dataTypeList.getDNDListComponent()).thenReturn(dndListComponent); when(dndListComponent.getPositionY(element)).thenReturn(expectedPositionY); final Integer actualPositionY = listItem.getPositionY(element); assertEquals(expectedPositionY, actualPositionY); } |
### Question:
DataTypeListItem { HTMLElement getDragAndDropListElement() { return getDNDListComponent().getElement(); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testGetDragAndDropListElement() { final DNDListComponent dndListComponent = mock(DNDListComponent.class); final HTMLElement expectedHTMLElement = mock(HTMLElement.class); when(dataTypeList.getDNDListComponent()).thenReturn(dndListComponent); when(dndListComponent.getElement()).thenReturn(expectedHTMLElement); final HTMLElement actualHTMLElement = listItem.getDragAndDropListElement(); assertEquals(expectedHTMLElement, actualHTMLElement); } |
### Question:
DataTypeListItem { void setupIndentationLevel() { setPositionX(getDragAndDropElement(), getLevel() - 1d); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testSetupIndentationLevel() { final HTMLElement dragAndDropElement = mock(HTMLElement.class); final DNDListComponent dndListComponent = mock(DNDListComponent.class); when(dataTypeList.getDNDListComponent()).thenReturn(dndListComponent); doReturn(dragAndDropElement).when(listItem).getDragAndDropElement(); doReturn(5).when(listItem).getLevel(); listItem.setupIndentationLevel(); verify(dndListComponent).setPositionX(dragAndDropElement, 4); } |
### Question:
DataTypeListItem { void hideTooltips() { final String selector = ".tooltip"; final NodeList<Element> tooltips = getDataTypeList().getListItems().querySelectorAll(selector); for (int i = 0; i < tooltips.length; i++) { ElementHelper.remove(tooltips.getAt(i)); } } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testHideTooltips() { final HTMLElement listItems = mock(HTMLElement.class); final NodeList<Element> tooltips = spy(new NodeList<>()); final Element element0 = mock(Element.class); final Element element1 = mock(Element.class); doReturn(element0).when(tooltips).getAt(0); doReturn(element1).when(tooltips).getAt(1); tooltips.length = 2; element0.parentNode = listItems; element1.parentNode = listItems; doReturn(listItems).when(dataTypeList).getListItems(); doReturn(tooltips).when(listItems).querySelectorAll(".tooltip"); listItem.hideTooltips(); verify(listItems).removeChild(element0); verify(listItems).removeChild(element1); } |
### Question:
DataTypeListItem { public void highlightLevel(final DataType dataType) { dataTypeList.highlightLevel(dataType); } @Inject DataTypeListItem(final View view,
final DataTypeSelect dataTypeSelectComponent,
final DataTypeConstraint dataTypeConstraintComponent,
final SmallSwitchComponent dataTypeListComponent,
final DataTypeManager dataTypeManager,
final DataTypeConfirmation confirmation,
final DataTypeNameFormatValidator nameFormatValidator,
final Event<DataTypeEditModeToggleEvent> editModeToggleEvent,
final Event<DataTypeChangedEvent> dataTypeChangedEvent); void init(final DataTypeList dataTypeList); DataType getDataType(); boolean isReadOnly(); int getLevel(); boolean isCollapsed(); void expand(); void collapse(); void enableEditMode(); void disableEditMode(); void saveAndCloseEditMode(); void remove(); Command removeItem(); Command destroy(); void destroyWithDependentTypes(); void destroyWithoutDependentTypes(); String getType(); void insertFieldAbove(); String insertFieldAbove(final DataType dataType); void insertFieldBelow(); String insertFieldBelow(final DataType dataType); void insertNestedField(); void insertNestedField(final DataType newDataType); HTMLElement getDragAndDropElement(); void highlightLevel(final DataType dataType); }### Answer:
@Test public void testHighlight() { final DataType dataType = mock(DataType.class); listItem.highlightLevel(dataType); verify(dataTypeList).highlightLevel(dataType); } |
### Question:
QNameConverter { public QName toModelValue(final String componentValue) { try { final List<String> matches = getRegexGroups(componentValue); if (matches.size() == 4) { final String namespace = matches.get(1); final String localPart = matches.get(2); final String prefix = matches.get(3); return new QName(namespace, localPart, prefix); } } catch (IllegalStateException ise) { } throw new IllegalArgumentException("Encoded form '" + componentValue + "' did not match '" + QNAME_DECODING_PATTERN + "'. Unable to convert to Model value."); } QNameConverter(); void setDMNModel(final DMNModelInstrumentedBase dmnModel); QName toModelValue(final String componentValue); String toWidgetValue(final QName modelValue); }### Answer:
@Test public void testToModelValueWithCorrectlyEncodedValue() { final QName typeRef = converter.toModelValue(ENCODED_FEEL_DATE); assertEquals(QName.NULL_NS_URI, typeRef.getPrefix()); assertEquals("", typeRef.getNamespaceURI()); assertEquals(BuiltInType.DATE.getName(), typeRef.getLocalPart()); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue() { converter.toModelValue(""); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue_NotEnoughBrackets() { converter.toModelValue("[][]"); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue_UnclosedBrackets() { converter.toModelValue("[][[]"); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue_UnopenBrackets() { converter.toModelValue("[]][]"); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue_TextOutside() { converter.toModelValue("a[]b[]c[]d"); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue_TextAtStart() { converter.toModelValue("a[][][]"); }
@Test(expected = IllegalArgumentException.class) public void testToModelValueWithIncorrectlyEncodedValue_TextAtEnd() { converter.toModelValue("[][][]d"); } |
### Question:
DataTypeSearchEngine { public List<DataType> search(final String keyword) { final List<DataType> results = new ArrayList<>(); for (final DataType dataType : findByName(keyword)) { results.addAll(getStack(dataType)); } return results; } @Inject DataTypeSearchEngine(final DataTypeStore dataTypeStore); List<DataType> search(final String keyword); }### Answer:
@Test public void testSearch() { final DataType tCity = makeDataType("001", "tCity", TOP_LEVEL_PARENT_UUID); final DataType tCityId = makeDataType("002", "id", "001"); final DataType tCityName = makeDataType("003", "name", "001"); final DataType tPerson = makeDataType("004", "tPerson", TOP_LEVEL_PARENT_UUID); final DataType tPersonId = makeDataType("005", "id", "004"); final DataType tPersonName = makeDataType("006", "name", "004"); final DataType tPersonCity = makeDataType("007", "city", "004"); final DataType tPersonCityId = makeDataType("008", "id", "007"); final DataType tPersonCityName = makeDataType("009", "name", "007"); index(tCity, tCityId, tCityName, tPerson, tPersonId, tPersonName, tPersonCity, tPersonCityId, tPersonCityName); final List<DataType> results = searchEngine.search("name"); assertTrue(results.contains(tCity)); assertFalse(results.contains(tCityId)); assertTrue(results.contains(tCityName)); assertTrue(results.contains(tPerson)); assertFalse(results.contains(tPersonId)); assertTrue(results.contains(tPersonName)); assertTrue(results.contains(tPersonCity)); assertFalse(results.contains(tPersonCityId)); assertTrue(results.contains(tPersonCityName)); }
@Test public void testSearchWhenKeywordIsEmpty() { final List<DataType> results = searchEngine.search(""); verifyNoMoreInteractions(dataTypeStore); assertTrue(results.isEmpty()); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { @PostConstruct public void setupSearchBar() { searchBar.placeholder = translationService.format(DataTypeSearchBarView_Search); } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testSetupSearchBar() { final String search = "Search..."; when(translationService.format(DataTypeSearchBarView_Search)).thenReturn(search); view.setupSearchBar(); assertEquals(searchBar.placeholder, search); } |
### Question:
DMNGridPanelControlImpl extends AbstractCanvasControl<AbstractCanvas> implements DMNGridPanelControl { @Override public void bind(final DMNSession session) { final DMNGridLayer gridLayer = session.getGridLayer(); final CellEditorControlsView.Presenter cellEditorControls = session.getCellEditorControls(); final RestrictedMousePanMediator mousePanMediator = session.getMousePanMediator(); final DMNGridPanelCellSelectionHandler selectionHandler = new DMNGridPanelCellSelectionHandlerImpl(gridLayer); final ContextMenuHandler contextMenuHandler = new DMNGridPanelContextMenuHandler(gridLayer, cellEditorControls, selectionHandler); this.panel = new DMNGridPanel(gridLayer, mousePanMediator, contextMenuHandler); } @Override void bind(final DMNSession session); @Override DMNGridPanel getGridPanel(); }### Answer:
@Test public void testBind() { control.bind(session); assertNotNull(control.getGridPanel()); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { @EventHandler("close-search") public void onSearchBarCloseButton(final ClickEvent e) { presenter.reset(); } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testOnSearchBarCloseButton() { view.onSearchBarCloseButton(mock(ClickEvent.class)); verify(presenter).reset(); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { @EventHandler("search-bar") public void onSearchBarKeyUpEvent(final KeyUpEvent event) { if (isEscape(event)) { presenter.reset(); } else { search(); } } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testOnSearchBarKeyUpEventWhenKeyPressedIsEscape() { final KeyUpEvent event = mock(KeyUpEvent.class); when(event.getNativeKeyCode()).thenReturn(KeyCodes.KEY_ESCAPE); view.onSearchBarKeyUpEvent(event); verify(presenter).reset(); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { @EventHandler("search-bar") public void onSearchBarKeyDownEvent(final KeyDownEvent e) { refreshSearchBarState(); } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testOnSearchBarKeyDownEvent() { view.onSearchBarKeyDownEvent(mock(KeyDownEvent.class)); verify(view).refreshSearchBarState(); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { @EventHandler("search-bar") public void onSearchBarChangeEvent(final ChangeEvent e) { refreshSearchBarState(); } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testOnSearchBarChangeEvent() { view.onSearchBarChangeEvent(mock(ChangeEvent.class)); verify(view).refreshSearchBarState(); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { void expandListItems(final List<DataTypeListItem> listItems) { for (final DataTypeListItem listItem : listItems) { listItem.expand(); } } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testExpandListItems() { final DataTypeListItem item1 = mock(DataTypeListItem.class); final DataTypeListItem item2 = mock(DataTypeListItem.class); final List<DataTypeListItem> list = asList(item1, item2); view.expandListItems(list); verify(item1).expand(); verify(item2).expand(); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { List<DataTypeListItem> groupElementsWithItsParents(final List<DataTypeListItem> allElements) { final List<DataTypeListItem> groupedElements = getGroupedElementsList(); for (final DataTypeListItem item : allElements) { groupElementWithItsParent(groupedElements, allElements, item); } return groupedElements; } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testGroupElementsWithItsParents() { final List<DataTypeListItem> groupedElementsList = mock(List.class); final DataTypeListItem element1 = mock(DataTypeListItem.class); final DataTypeListItem element2 = mock(DataTypeListItem.class); final List<DataTypeListItem> allElements = Arrays.asList(element1, element2); doReturn(groupedElementsList).when(view).getGroupedElementsList(); doNothing().when(view).groupElementWithItsParent(groupedElementsList, allElements, element1); doNothing().when(view).groupElementWithItsParent(groupedElementsList, allElements, element2); final List<DataTypeListItem> actual = view.groupElementsWithItsParents(allElements); verify(view).groupElementWithItsParent(groupedElementsList, allElements, element1); verify(view).groupElementWithItsParent(groupedElementsList, allElements, element2); assertEquals(actual, groupedElementsList); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { int getIndexOfParentOrLastElementInGroup(final List<DataTypeListItem> groupedElements, final DataTypeListItem parent) { final int parentIndex = groupedElements.indexOf(parent); final String parentId = parent.getDragAndDropElement().getAttribute(UUID_ATTR); int index = parentIndex; for (int i = parentIndex; i < groupedElements.size(); i++) { if (Objects.equals(groupedElements.get(i).getDragAndDropElement().getAttribute(PARENT_UUID_ATTR), parentId)) { index++; } } return index; } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testGetIndexOfParentOrLastElementInGroup() { final DataTypeListItem parent = mock(DataTypeListItem.class); final HTMLElement parentElement = mock(HTMLElement.class); final String parentId = "parentId"; final List<DataTypeListItem> groupedElements = new ArrayList<>(); groupedElements.add(parent); final int expectedIndex = 0; when(parentElement.getAttribute(UUID_ATTR)).thenReturn(parentId); when(parent.getDragAndDropElement()).thenReturn(parentElement); final int index = view.getIndexOfParentOrLastElementInGroup(groupedElements, parent); assertEquals(expectedIndex, index); }
@Test public void testGetIndexOfParentOrLastElementInGroupWhenHaveMoreElements() { final DataTypeListItem parent = mock(DataTypeListItem.class); final DataTypeListItem listItem1 = mock(DataTypeListItem.class); final DataTypeListItem listItem2 = mock(DataTypeListItem.class); final HTMLElement parentElement = mock(HTMLElement.class); final HTMLElement listItemElement1 = mock(HTMLElement.class); final HTMLElement listItemElement2 = mock(HTMLElement.class); final String parentId = "parentId"; final List<DataTypeListItem> groupedElements = new ArrayList<>(); groupedElements.add(parent); groupedElements.add(listItem1); groupedElements.add(listItem2); final int expectedIndex = 2; when(parentElement.getAttribute(UUID_ATTR)).thenReturn(parentId); when(parent.getDragAndDropElement()).thenReturn(parentElement); when(listItem1.getDragAndDropElement()).thenReturn(listItemElement1); when(listItem2.getDragAndDropElement()).thenReturn(listItemElement2); when(listItemElement1.getAttribute(PARENT_UUID_ATTR)).thenReturn(parentId); when(listItemElement2.getAttribute(PARENT_UUID_ATTR)).thenReturn(parentId); final int index = view.getIndexOfParentOrLastElementInGroup(groupedElements, parent); assertEquals(expectedIndex, index); } |
### Question:
DataTypeSearchBarView implements DataTypeSearchBar.View { boolean isParentElementOnList(final List<DataTypeListItem> groupedElements, final String parentId) { return groupedElements.stream() .anyMatch(element -> Objects.equals(element.getDragAndDropElement().getAttribute(UUID_ATTR), parentId)); } @Inject DataTypeSearchBarView(final HTMLInputElement searchBar,
final @Named("span") HTMLElement searchIcon,
final HTMLButtonElement closeSearch,
final TranslationService translationService); @PostConstruct void setupSearchBar(); @Override void init(final DataTypeSearchBar presenter); @EventHandler("close-search") void onSearchBarCloseButton(final ClickEvent e); @EventHandler("search-bar") void onSearchBarKeyUpEvent(final KeyUpEvent event); @EventHandler("search-bar") void onSearchBarKeyDownEvent(final KeyDownEvent e); @EventHandler("search-bar") void onSearchBarChangeEvent(final ChangeEvent e); @Override void resetSearchBar(); @Override void showSearchResults(final List<DataType> results); void refreshItemsPosition(); }### Answer:
@Test public void testIsParentElementOnListWhenIsPresent() { final DataTypeListItem item = mock(DataTypeListItem.class); final HTMLElement element = mock(HTMLElement.class); final String id = "id"; when(element.getAttribute(UUID_ATTR)).thenReturn(id); when(item.getDragAndDropElement()).thenReturn(element); final List<DataTypeListItem> groupedElements = Arrays.asList(item); boolean isPresent = view.isParentElementOnList(groupedElements, id); assertTrue(isPresent); }
@Test public void testIsParentElementOnListWhenIsNotPresent() { final DataTypeListItem item = mock(DataTypeListItem.class); final HTMLElement element = mock(HTMLElement.class); final String id = "id"; when(element.getAttribute(UUID_ATTR)).thenReturn("otherId"); when(item.getDragAndDropElement()).thenReturn(element); final List<DataTypeListItem> groupedElements = Arrays.asList(item); boolean isPresent = view.isParentElementOnList(groupedElements, id); assertFalse(isPresent); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.