method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
NodeDefinitionHelper { public static String getDiagramId(final Node node) { if (node.getContent() instanceof Definition) { final Object definition = ((Definition) node.getContent()).getDefinition(); if (definition instanceof HasContentDefinitionId) { return ((HasContentDefinitionId) definition).getDiagramId(); } } return null; } static String getDiagramId(final Node node); static String getContentDefinitionId(final Node node); }### Answer:
@Test public void testGetDiagram() { final String diagramId = "diagramId"; final Node node = createNode("id", diagramId); final String actual = getDiagramId(node); assertEquals(diagramId, actual); } |
### Question:
NodeDefinitionHelper { public static String getContentDefinitionId(final Node node) { if (node.getContent() instanceof Definition) { final Object definition = ((Definition) node.getContent()).getDefinition(); if (definition instanceof HasContentDefinitionId) { return ((HasContentDefinitionId) definition).getContentDefinitionId(); } } return null; } static String getDiagramId(final Node node); static String getContentDefinitionId(final Node node); }### Answer:
@Test public void testGetContentDefinitionId() { final String contentDefinitionId = "contentDefinitionId"; final Node node = createNode(contentDefinitionId, "id"); final String actual = getContentDefinitionId(node); assertEquals(contentDefinitionId, actual); } |
### Question:
SafeDeleteNodeProcessor { void init() { this.candidateContentDefinitionId = getContentDefinitionId(candidate); this.candidateDiagramId = getDiagramId(candidate); } SafeDeleteNodeProcessor(final ChildrenTraverseProcessor childrenTraverseProcessor,
final Graph graph,
final Node<Definition<?>, Edge> candidate); SafeDeleteNodeProcessor(final ChildrenTraverseProcessor childrenTraverseProcessor,
final Graph graph,
final Node<Definition<?>, Edge> candidate,
final boolean keepChildren,
final TreeWalkTraverseProcessor treeWalkTraverseProcessor,
final GraphsProvider graphsProvider); @SuppressWarnings("unchecked") void run(final Callback callback); String getCandidateDiagramId(); String getCandidateContentDefinitionId(); }### Answer:
@Test public void testInit() { final Graph graph = mock(Graph.class); final Node node = mock(Node.class); final Definition definition = mock(Definition.class); final HasContentDefinitionId hasContentDefinitionId = mock(HasContentDefinitionId.class); final String definitionId = "definition id"; final String dmnDiagramId = "dmn diagram id"; when(node.getContent()).thenReturn(definition); when(definition.getDefinition()).thenReturn(hasContentDefinitionId); when(hasContentDefinitionId.getContentDefinitionId()).thenReturn(definitionId); when(hasContentDefinitionId.getDiagramId()).thenReturn(dmnDiagramId); this.tested = new SafeDeleteNodeProcessor(new ChildrenTraverseProcessorImpl(new TreeWalkTraverseProcessorImpl()), graph, node); tested.init(); final String candidateContentDefinitionId = tested.getCandidateContentDefinitionId(); final String candidateDmnDiagramId = tested.getCandidateDiagramId(); assertEquals(definitionId, candidateContentDefinitionId); assertEquals(dmnDiagramId, candidateDmnDiagramId); } |
### Question:
SafeDeleteNodeProcessor { boolean processGlobalNodeForDeletion(final Node node, final Deque<Node<View, Edge>> nodes) { final String nodeId = getContentDefinitionId(node); final String diagramId = getDiagramId(node); if (isDuplicatedOnTheCurrentDiagram(node, nodeId, diagramId)) { nodes.clear(); return false; } if (Objects.equals(getCandidateContentDefinitionId(), nodeId) && !Objects.equals(node, candidate)) { nodes.add(node); } return true; } SafeDeleteNodeProcessor(final ChildrenTraverseProcessor childrenTraverseProcessor,
final Graph graph,
final Node<Definition<?>, Edge> candidate); SafeDeleteNodeProcessor(final ChildrenTraverseProcessor childrenTraverseProcessor,
final Graph graph,
final Node<Definition<?>, Edge> candidate,
final boolean keepChildren,
final TreeWalkTraverseProcessor treeWalkTraverseProcessor,
final GraphsProvider graphsProvider); @SuppressWarnings("unchecked") void run(final Callback callback); String getCandidateDiagramId(); String getCandidateContentDefinitionId(); }### Answer:
@Test public void testProcessGlobalNodeForDeletion() { final Deque deque = mock(Deque.class); final String nodeId = "id"; final Node node = createNode(nodeId, "diagramId"); this.tested = mock(SafeDeleteNodeProcessor.class); when(tested.getCandidateContentDefinitionId()).thenReturn(nodeId); when(tested.isDuplicatedOnTheCurrentDiagram(eq(node), anyString(), anyString())).thenReturn(false); when(tested.processGlobalNodeForDeletion(node, deque)).thenCallRealMethod(); final boolean shouldDeleteDuplicatedDRGNodes = tested.processGlobalNodeForDeletion(node, deque); verify(deque).add(node); assertTrue(shouldDeleteDuplicatedDRGNodes); } |
### Question:
GraphProcessorImpl implements GraphProcessor { public Iterable<? extends Node> getNodes(final Graph<?, ?> graph) { return graph.nodes(); } Iterable<? extends Node> getNodes(final Graph<?, ?> graph); }### Answer:
@Test public void testGetNodes() { final GraphProcessorImpl tested = new GraphProcessorImpl(); final Graph<?, ?> graph = mock(Graph.class); final Iterable nodes = mock(Iterable.class); when(graph.nodes()).thenReturn(nodes); final Iterable<? extends Node> actual = tested.getNodes(graph); assertEquals(nodes, actual); } |
### Question:
DefaultVertexPositioning implements VertexPositioning { @Override public void calculateVerticesPositions(final ReorderedGraph graph, final LayerArrangement arrangement) { final LayeredGraph layered = (LayeredGraph) graph; deReverseEdges(graph); final Set<Vertex> vertices = getVertices(layered); removeVirtualVertices(graph.getEdges(), vertices); removeVirtualVerticesFromLayers(layered.getLayers(), vertices); arrangeVertices(layered.getLayers(), arrangement, graph); } @Override void calculateVerticesPositions(final ReorderedGraph graph,
final LayerArrangement arrangement); boolean removeVirtualVertex(final OrientedEdge edge,
final List<OrientedEdge> edges,
final Set<Vertex> vertices); void removeVirtualVertices(final List<OrientedEdge> edges,
final Set<Vertex> vertices); }### Answer:
@Test public void testCalculateVerticesPositions() { final DefaultVertexPositioning tested = mock(DefaultVertexPositioning.class); final LayeredGraph graph = mock(LayeredGraph.class); final List<OrientedEdge> edges = mock(List.class); final LayerArrangement arrangement = LayerArrangement.BottomUp; final Set<Vertex> vertices = mock(Set.class); when(tested.getVertices(graph)).thenReturn(vertices); final List<GraphLayer> layers = mock(List.class); when(graph.getLayers()).thenReturn(layers); when(graph.getEdges()).thenReturn(edges); doCallRealMethod().when(tested).calculateVerticesPositions(graph, arrangement); tested.calculateVerticesPositions(graph, arrangement); final InOrder inOrder = inOrder(tested); inOrder.verify(tested).deReverseEdges(graph); inOrder.verify(tested).getVertices(graph); inOrder.verify(tested).removeVirtualVertices(edges, vertices); inOrder.verify(tested).removeVirtualVerticesFromLayers(layers, vertices); inOrder.verify(tested).arrangeVertices(layers, arrangement, graph); } |
### Question:
DefaultVertexPositioning implements VertexPositioning { Set<Vertex> getVertices(final LayeredGraph layered) { return layered.getLayers().stream() .flatMap(l -> l.getVertices().stream()).collect(Collectors.toSet()); } @Override void calculateVerticesPositions(final ReorderedGraph graph,
final LayerArrangement arrangement); boolean removeVirtualVertex(final OrientedEdge edge,
final List<OrientedEdge> edges,
final Set<Vertex> vertices); void removeVirtualVertices(final List<OrientedEdge> edges,
final Set<Vertex> vertices); }### Answer:
@Test public void testGetVertices() { final LayeredGraph graph = new LayeredGraph(); final GraphLayer layer1 = mock(GraphLayer.class); final GraphLayer layer2 = mock(GraphLayer.class); final List<Vertex> vertices1 = new ArrayList<>(); final List<Vertex> vertices2 = new ArrayList<>(); final Vertex v1 = mock(Vertex.class); final Vertex v2 = mock(Vertex.class); final Vertex v3 = mock(Vertex.class); vertices1.add(v1); vertices1.add(v2); vertices1.add(v3); when(layer1.getVertices()).thenReturn(vertices1); when(layer2.getVertices()).thenReturn(vertices2); graph.getLayers().add(layer1); graph.getLayers().add(layer2); final Set<Vertex> actual = tested.getVertices(graph); assertTrue(actual.contains(v1)); assertTrue(actual.contains(v2)); assertTrue(actual.contains(v3)); assertEquals(3, actual.size()); } |
### Question:
DefaultVertexPositioning implements VertexPositioning { void deReverseEdges(final ReorderedGraph graph) { for (final OrientedEdge edge : graph.getEdges()) { if (edge.isReversed()) { edge.reverse(); } } } @Override void calculateVerticesPositions(final ReorderedGraph graph,
final LayerArrangement arrangement); boolean removeVirtualVertex(final OrientedEdge edge,
final List<OrientedEdge> edges,
final Set<Vertex> vertices); void removeVirtualVertices(final List<OrientedEdge> edges,
final Set<Vertex> vertices); }### Answer:
@Test public void testDeReverseEdges() { final LayeredGraph graph = new LayeredGraph(); final OrientedEdgeImpl e1 = new OrientedEdgeImpl("1", "2", true); final OrientedEdgeImpl e2 = new OrientedEdgeImpl("2", "3", false); final OrientedEdgeImpl e3 = new OrientedEdgeImpl("2", "4", true); graph.addEdge(e1); graph.addEdge(e2); graph.addEdge(e3); tested.deReverseEdges(graph); assertFalse(e1.isReversed()); assertFalse(e2.isReversed()); assertFalse(e3.isReversed()); } |
### Question:
DefaultVertexPositioning implements VertexPositioning { HashMap<Integer, Integer> getLayersStartX(final int layersCount, final HashMap<Integer, Integer> layersWidth, final int largestWidth) { final HashMap<Integer, Integer> layersStartX = new HashMap<>(); for (int i = 0; i < layersCount; i++) { final int middle = largestWidth / 2; final int layerWidth = layersWidth.get(i); final int firstHalf = layerWidth / 2; int startPoint = middle - firstHalf; startPoint += DEFAULT_LAYER_HORIZONTAL_PADDING; layersStartX.put(i, startPoint); } return layersStartX; } @Override void calculateVerticesPositions(final ReorderedGraph graph,
final LayerArrangement arrangement); boolean removeVirtualVertex(final OrientedEdge edge,
final List<OrientedEdge> edges,
final Set<Vertex> vertices); void removeVirtualVertices(final List<OrientedEdge> edges,
final Set<Vertex> vertices); }### Answer:
@Test public void testGetLayersStartX() { final int largestWidth = 600; final int layersCount = 3; final HashMap<Integer, Integer> layersWidth = new HashMap<>(); layersWidth.put(0, 200); layersWidth.put(1, 600); layersWidth.put(2, 300); final HashMap<Integer, Integer> startX = tested.getLayersStartX(layersCount, layersWidth, largestWidth); assertEquals(200 + DEFAULT_LAYER_HORIZONTAL_PADDING, (int) startX.get(0)); assertEquals(0 + DEFAULT_LAYER_HORIZONTAL_PADDING, (int) startX.get(1)); assertEquals(150 + DEFAULT_LAYER_HORIZONTAL_PADDING, (int) startX.get(2)); } |
### Question:
DefaultVertexPositioning implements VertexPositioning { int calculateLayersWidth(final List<GraphLayer> layers, final HashMap<Integer, Integer> layersWidth) { int largestWidth = 0; for (int i = 0; i < layers.size(); i++) { final GraphLayer layer = layers.get(i); int currentWidth = layer.getVertices().size() * DEFAULT_VERTEX_WIDTH; currentWidth += (layer.getVertices().size() - 1) * DEFAULT_VERTEX_SPACE; layersWidth.put(i, currentWidth); largestWidth = Math.max(largestWidth, currentWidth); } return largestWidth; } @Override void calculateVerticesPositions(final ReorderedGraph graph,
final LayerArrangement arrangement); boolean removeVirtualVertex(final OrientedEdge edge,
final List<OrientedEdge> edges,
final Set<Vertex> vertices); void removeVirtualVertices(final List<OrientedEdge> edges,
final Set<Vertex> vertices); }### Answer:
@Test public void testGetLargestWidth() { final GraphLayer layer1 = createGraphLayer(2); final int expectedSize1 = getExpectSize(2); final GraphLayer layer2 = createGraphLayer(4); final int expectedSize2 = getExpectSize(4); final GraphLayer layer3 = createGraphLayer(1); final int expectedSize3 = getExpectSize(1); final List<GraphLayer> layers = Arrays.asList(layer1, layer2, layer3); final HashMap<Integer, Integer> layersWidth = new HashMap<>(); final int largest = tested.calculateLayersWidth(layers, layersWidth); assertEquals(expectedSize2, largest); assertEquals((int) layersWidth.get(0), expectedSize1); assertEquals((int) layersWidth.get(1), expectedSize2); assertEquals((int) layersWidth.get(2), expectedSize3); } |
### Question:
LayeredGraph implements ReorderedGraph { @Override public int getVertexHeight(final String vertexId) { final int height = verticesHeight.getOrDefault(vertexId, DEFAULT_VERTEX_HEIGHT); return height; } LayeredGraph(); LayeredGraph(final String[][] edgesMatrix); void addEdge(final String from,
final String to); void addEdge(final OrientedEdgeImpl edge); List<GraphLayer> getLayers(); List<String> getVertices(); @Override List<OrientedEdge> getEdges(); @Override int getVertexHeight(final String vertexId); @Override int getVertexWidth(final String vertexId); @Override void setVertexSize(final String vertexId, final int width, final int height); boolean isAcyclic(); String[] getVerticesFrom(final String vertex); }### Answer:
@Test public void testGetVertexHeight() { final int width = 10; final int height = 20; final String id = "1"; int actual = tested.getVertexHeight(id); assertEquals(DEFAULT_VERTEX_HEIGHT, actual); tested.setVertexSize(id, width, height); actual = tested.getVertexHeight(id); assertEquals(height, actual); } |
### Question:
LayeredGraph implements ReorderedGraph { @Override public int getVertexWidth(final String vertexId) { final int width = verticesWidth.getOrDefault(vertexId, DEFAULT_VERTEX_WIDTH); return width; } LayeredGraph(); LayeredGraph(final String[][] edgesMatrix); void addEdge(final String from,
final String to); void addEdge(final OrientedEdgeImpl edge); List<GraphLayer> getLayers(); List<String> getVertices(); @Override List<OrientedEdge> getEdges(); @Override int getVertexHeight(final String vertexId); @Override int getVertexWidth(final String vertexId); @Override void setVertexSize(final String vertexId, final int width, final int height); boolean isAcyclic(); String[] getVerticesFrom(final String vertex); }### Answer:
@Test public void testGetVertexWidth() { final int width = 10; final int height = 20; final String id = "1"; int actual = tested.getVertexWidth(id); assertEquals(DEFAULT_VERTEX_WIDTH, actual); tested.setVertexSize(id, width, height); actual = tested.getVertexWidth(id); assertEquals(width, actual); } |
### Question:
LayeredGraph implements ReorderedGraph { @Override public void setVertexSize(final String vertexId, final int width, final int height) { verticesWidth.put(vertexId, width); verticesHeight.put(vertexId, height); } LayeredGraph(); LayeredGraph(final String[][] edgesMatrix); void addEdge(final String from,
final String to); void addEdge(final OrientedEdgeImpl edge); List<GraphLayer> getLayers(); List<String> getVertices(); @Override List<OrientedEdge> getEdges(); @Override int getVertexHeight(final String vertexId); @Override int getVertexWidth(final String vertexId); @Override void setVertexSize(final String vertexId, final int width, final int height); boolean isAcyclic(); String[] getVerticesFrom(final String vertex); }### Answer:
@Test public void testSetVertexSize() { final int width = 15; final int height = 17; final String id = "1"; tested.setVertexSize(id, width, height); final int actualWidth = tested.getVertexWidth(id); final int actualHeight = tested.getVertexHeight(id); assertEquals(width, actualWidth); assertEquals(height, actualHeight); } |
### Question:
SugiyamaLayoutService extends AbstractLayoutService { HashMap<String, Node> createIndex(final Iterable<? extends Node> nodes) { final HashMap<String, Node> indexByUuid = new HashMap<>(); for (final Node n : nodes) { if (!(n.getContent() instanceof HasBounds)) { continue; } indexByUuid.put(n.getUUID(), n); } return indexByUuid; } @Inject SugiyamaLayoutService(final CycleBreaker cycleBreaker,
final VertexLayerer vertexLayerer,
final VertexOrdering vertexOrdering,
final VertexPositioning vertexPositioning,
final GraphProcessor graphProcessor); @Override Layout createLayout(final Graph<?, ?> graph); }### Answer:
@Test public void testCreateIndex() { final Node nodeWithoutBounds = mock(Node.class); final String noBoundsId = "not"; final String id1 = "id1"; final String id2 = "id2"; final Object notHasBoundsInstance = mock(Object.class); final Node n1 = createNode(id1); final Node n2 = createNode(id2); final List<Node> nodes = Arrays.asList(n1, n2, nodeWithoutBounds); when(nodeWithoutBounds.getUUID()).thenReturn(noBoundsId); when(nodeWithoutBounds.getContent()).thenReturn(notHasBoundsInstance); final HashMap<String, Node> index = layoutService.createIndex(nodes); assertTrue(index.containsKey(id1)); assertTrue(index.containsKey(id2)); assertFalse(index.containsKey(noBoundsId)); assertEquals(n1, index.get(id1)); assertEquals(n2, index.get(id2)); } |
### Question:
SugiyamaLayoutService extends AbstractLayoutService { LayeredGraph createLayeredGraph(final Iterable<? extends Node> nodes) { final LayeredGraph layeredGraph = getLayeredGraph(); for (final Node n : nodes) { addInEdges(layeredGraph, n); addOutEdges(layeredGraph, n); } return layeredGraph; } @Inject SugiyamaLayoutService(final CycleBreaker cycleBreaker,
final VertexLayerer vertexLayerer,
final VertexOrdering vertexOrdering,
final VertexPositioning vertexPositioning,
final GraphProcessor graphProcessor); @Override Layout createLayout(final Graph<?, ?> graph); }### Answer:
@Test public void testCreateLayeredGraph() { final Node n1 = createNode("id1"); final Node n2 = createNode("id2"); final List<Node> nodes = Arrays.asList(n1, n2); final LayeredGraph layeredGraph = mock(LayeredGraph.class); doReturn(layeredGraph).when(layoutService).getLayeredGraph(); doNothing().when(layoutService).addInEdges(layeredGraph, n1); doNothing().when(layoutService).addOutEdges(layeredGraph, n1); doNothing().when(layoutService).addInEdges(layeredGraph, n2); doNothing().when(layoutService).addOutEdges(layeredGraph, n2); layoutService.createLayeredGraph(nodes); verify(layoutService).addInEdges(layeredGraph, n1); verify(layoutService).addInEdges(layeredGraph, n2); verify(layoutService).addOutEdges(layeredGraph, n1); verify(layoutService).addOutEdges(layeredGraph, n2); } |
### Question:
SugiyamaLayoutService extends AbstractLayoutService { void addInEdges(final LayeredGraph layeredGraph, final Node n) { for (final Object e : n.getInEdges()) { if (e instanceof Edge) { final Edge edge = (Edge) e; final String from = getId(edge.getSourceNode()); final String to = getId(n); layeredGraph.addEdge(from, to); layeredGraph.setVertexSize(getId(n), getWidth(n), getHeight(n)); } } } @Inject SugiyamaLayoutService(final CycleBreaker cycleBreaker,
final VertexLayerer vertexLayerer,
final VertexOrdering vertexOrdering,
final VertexPositioning vertexPositioning,
final GraphProcessor graphProcessor); @Override Layout createLayout(final Graph<?, ?> graph); }### Answer:
@Test public void testAddInEdges() { final LayeredGraph layeredGraph = mock(LayeredGraph.class); final Node node = mock(Node.class); final Edge edge = mock(Edge.class); final Node sourceNode = mock(Node.class); final List inEdges = Arrays.asList(edge); final String fromId = "from"; final String toId = "to"; final int width = 10; final int height = 20; when(node.getInEdges()).thenReturn(inEdges); when(edge.getSourceNode()).thenReturn(sourceNode); doReturn(fromId).when(layoutService).getId(sourceNode); doReturn(toId).when(layoutService).getId(node); doReturn(width).when(layoutService).getWidth(node); doReturn(height).when(layoutService).getHeight(node); layoutService.addInEdges(layeredGraph, node); verify(layeredGraph).addEdge(fromId, toId); verify(layeredGraph).setVertexSize(toId, width, height); } |
### Question:
SugiyamaLayoutService extends AbstractLayoutService { void addOutEdges(final LayeredGraph layeredGraph, final Node n) { for (final Object e : n.getOutEdges()) { if (e instanceof Edge) { final Edge edge = (Edge) e; final String to = getId(edge.getTargetNode()); final String from = getId(n); layeredGraph.addEdge(from, to); layeredGraph.setVertexSize(getId(n), getWidth(n), getHeight(n)); } } } @Inject SugiyamaLayoutService(final CycleBreaker cycleBreaker,
final VertexLayerer vertexLayerer,
final VertexOrdering vertexOrdering,
final VertexPositioning vertexPositioning,
final GraphProcessor graphProcessor); @Override Layout createLayout(final Graph<?, ?> graph); }### Answer:
@Test public void testAddOutEdges() { final LayeredGraph layeredGraph = mock(LayeredGraph.class); final Node node = mock(Node.class); final Edge edge = mock(Edge.class); final Node targetNode = mock(Node.class); final List outEdges = Arrays.asList(edge); final String fromId = "from"; final String toId = "to"; final int width = 10; final int height = 20; when(node.getOutEdges()).thenReturn(outEdges); when(edge.getTargetNode()).thenReturn(targetNode); doReturn(fromId).when(layoutService).getId(node); doReturn(toId).when(layoutService).getId(targetNode); doReturn(width).when(layoutService).getWidth(node); doReturn(height).when(layoutService).getHeight(node); layoutService.addOutEdges(layeredGraph, node); verify(layeredGraph).addEdge(fromId, toId); verify(layeredGraph).setVertexSize(fromId, width, height); } |
### Question:
SugiyamaLayoutService extends AbstractLayoutService { int getHeight(final Node n) { return (int) ((HasBounds) n.getContent()).getBounds().getHeight(); } @Inject SugiyamaLayoutService(final CycleBreaker cycleBreaker,
final VertexLayerer vertexLayerer,
final VertexOrdering vertexOrdering,
final VertexPositioning vertexPositioning,
final GraphProcessor graphProcessor); @Override Layout createLayout(final Graph<?, ?> graph); }### Answer:
@Test public void testGetHeight() { final Node n = mock(Node.class); final HasBounds hasBounds = mock(HasBounds.class); final Bounds bounds = mock(Bounds.class); final double height = 15; final int expected = (int) height; when(bounds.getHeight()).thenReturn(height); when(hasBounds.getBounds()).thenReturn(bounds); when(n.getContent()).thenReturn(hasBounds); int actual = layoutService.getHeight(n); assertEquals(expected, actual); } |
### Question:
SugiyamaLayoutService extends AbstractLayoutService { int getWidth(final Node n) { return (int) ((HasBounds) n.getContent()).getBounds().getWidth(); } @Inject SugiyamaLayoutService(final CycleBreaker cycleBreaker,
final VertexLayerer vertexLayerer,
final VertexOrdering vertexOrdering,
final VertexPositioning vertexPositioning,
final GraphProcessor graphProcessor); @Override Layout createLayout(final Graph<?, ?> graph); }### Answer:
@Test public void testGetWidth() { final Node n = mock(Node.class); final HasBounds hasBounds = mock(HasBounds.class); final Bounds bounds = mock(Bounds.class); final double width = 17; final int expected = (int) width; when(bounds.getWidth()).thenReturn(width); when(hasBounds.getBounds()).thenReturn(bounds); when(n.getContent()).thenReturn(hasBounds); int actual = layoutService.getWidth(n); assertEquals(expected, actual); } |
### Question:
ReverseEdgesCycleBreaker implements CycleBreaker { @Override public void breakCycle(final ReorderedGraph graph) { this.graph = (LayeredGraph) graph; for (final String vertex : this.graph.getVertices()) { visit(vertex); } } ReverseEdgesCycleBreaker(); @Override void breakCycle(final ReorderedGraph graph); }### Answer:
@Test public void testAcyclicGraphs() { final LayeredGraph graph = new LayeredGraph(Graphs.SIMPLE_ACYCLIC); final ReverseEdgesCycleBreaker breaker = new ReverseEdgesCycleBreaker(); breaker.breakCycle(graph); assertTrue(graph.isAcyclic()); }
@Test public void testSimpleCyclicGraph() { final LayeredGraph graph = new LayeredGraph(Graphs.SIMPLE_CYCLIC); graph.addEdge("A", "B"); graph.addEdge("B", "C"); graph.addEdge("C", "D"); graph.addEdge("D", "A"); assertFalse(graph.isAcyclic()); final ReverseEdgesCycleBreaker breaker = new ReverseEdgesCycleBreaker(); breaker.breakCycle(graph); assertTrue(graph.isAcyclic()); }
@Test public void testCyclicGraph1() { final LayeredGraph graph = new LayeredGraph(Graphs.CYCLIC_GRAPH_1); final ReverseEdgesCycleBreaker breaker = new ReverseEdgesCycleBreaker(); breaker.breakCycle(graph); assertTrue(graph.isAcyclic()); }
@Test public void testCyclicGraphFull() { final LayeredGraph graph = new LayeredGraph(Graphs.Full); assertFalse(graph.isAcyclic()); final ReverseEdgesCycleBreaker breaker = new ReverseEdgesCycleBreaker(); breaker.breakCycle(graph); assertTrue(graph.isAcyclic()); } |
### Question:
AbstractLayoutService implements LayoutService { protected double getLayoutInformationThreshold(final Graph<?, ?> graph) { final List<Node> list = new ArrayList<>(); graph.nodes().iterator().forEachRemaining(list::add); return list.size() / 4.0D; } @Override boolean hasLayoutInformation(final Graph<?, ?> graph); @Override abstract Layout createLayout(Graph<?, ?> graph); }### Answer:
@Test public void getLayoutInformationThreshold() { when(n1.getUUID()).thenReturn(UUID.uuid()); when(n2.getUUID()).thenReturn(UUID.uuid()); final GraphNodeStoreImpl store = new GraphNodeStoreImpl(); store.add(n1); doCallRealMethod().when(layoutService).getLayoutInformationThreshold(graph); when(graph.nodes()).thenReturn(store); double threshold = layoutService.getLayoutInformationThreshold(graph); assertEquals(0.25, threshold, 0.01); store.add(n2); threshold = layoutService.getLayoutInformationThreshold(graph); assertEquals(0.50, threshold, 0.01); } |
### Question:
AbstractLayoutService implements LayoutService { @Override public boolean hasLayoutInformation(final Graph<?, ?> graph) { final double threshold = getLayoutInformationThreshold(graph); int nodesWithLayout = 0; for (final Node n : graph.nodes()) { final Object content = n.getContent(); if (content instanceof HasBounds) { if (!isNullOrCloseToZero(((HasBounds) content).getBounds())) { nodesWithLayout++; } } if (nodesWithLayout >= threshold) { return true; } } return false; } @Override boolean hasLayoutInformation(final Graph<?, ?> graph); @Override abstract Layout createLayout(Graph<?, ?> graph); }### Answer:
@Test public void hasLayoutInformation() { when(n1.getUUID()).thenReturn(UUID.uuid()); when(n2.getUUID()).thenReturn(UUID.uuid()); final GraphNodeStoreImpl store = new GraphNodeStoreImpl(); store.add(n2); store.add(n1); doCallRealMethod().when(layoutService).hasLayoutInformation(graph); doCallRealMethod().when(layoutService).getLayoutInformationThreshold(graph); when(graph.nodes()).thenReturn(store); assertFalse(layoutService.hasLayoutInformation(graph)); final Bounds bounds = Bounds.create(10, 10, 10, 10); final Bounds noBounds = Bounds.create(0, 0, 0, 0); when(n1.getContent()).thenReturn(hasBounds1); when(hasBounds1.getBounds()).thenReturn(noBounds); when(n2.getContent()).thenReturn(hasBounds2); when(hasBounds2.getBounds()).thenReturn(bounds); assertTrue(layoutService.hasLayoutInformation(graph)); } |
### Question:
ContextualGraphCommandExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } ContextualGraphCommandExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); ContextualGraphCommandExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluate() { StatefulGraphEvaluationState.StatefulContainmentState containmentState = new StatefulGraphEvaluationState.StatefulContainmentState(); when(state.getContainmentState()).thenReturn(containmentState); Element parent = new NodeImpl<>("parent"); Node child = new NodeImpl<>("child"); final NodeContainmentContext[] containmentContext = new NodeContainmentContext[1]; tested.evaluate(builder -> containmentContext[0] = builder.containment(parent, child)); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(containmentContext[0])); assertEquals(parent, containmentState.getParent(child)); } |
### Question:
ContextualGraphCommandExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } ContextualGraphCommandExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); ContextualGraphCommandExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); }### Answer:
@Test public void testClear() { tested.clear(); verify(state, times(1)).clear(); } |
### Question:
DirectGraphCommandExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { return EmptyRuleViolations.INSTANCE; } DirectGraphCommandExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final Index<?, ?> graphIndex); DirectGraphCommandExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleEvaluationContextBuilder.StatelessGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testEvaluate() { when(contextBuilder.containment(any(Element.class), any(Node.class))).thenReturn(mock(NodeContainmentContext.class)); RuleViolations result = tested.evaluate(builder -> builder.containment(mock(Element.class), mock(Node.class))); assertEquals(EmptyRuleViolations.INSTANCE, result); } |
### Question:
UnDockNodeCommand extends AbstractGraphCommand { @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final CommandResult<RuleViolation> results = allow(context); if (!results.getType().equals(CommandResult.Type.ERROR)) { final Node<?, Edge> parent = getParent(context); final Node<?, Edge> candidate = getCandidate(context); parent.getOutEdges().stream() .filter(e -> e.getContent() instanceof Dock) .filter(e -> e.getTargetNode().equals(candidate)) .findFirst() .ifPresent(e -> removeDockEdge(context, parent, candidate, e)); } return results; } UnDockNodeCommand(final @MapsTo("parentUUID") String parentUUID,
final @MapsTo("candidateUUID") String candidateUUID); UnDockNodeCommand(final Node<?, Edge> parent,
final Node<?, Edge> candidate); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); Node<?, Edge> getParent(); Node<?, Edge> getCandidate(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); assertTrue(parentOutEdges.isEmpty()); assertTrue(candidateInEdges.isEmpty()); verify(graphIndex, times(1)).removeEdge(eq(edge)); verify(graphIndex, times(0)).removeNode(any(Node.class)); verify(graph, times(0)).addNode(any(Node.class)); verify(graphIndex, times(0)).addNode(any(Node.class)); verify(graphIndex, times(0)).addEdge(any(Edge.class)); } |
### Question:
AddDockedNodeCommand extends AbstractGraphCompositeCommand { protected AddDockedNodeCommand initialize(final GraphCommandExecutionContext context) { super.initialize(context); this.addCommand(new RegisterNodeCommand(candidate)) .addCommand(new DockNodeCommand(getParent(context), candidate)); return this; } AddDockedNodeCommand(final @MapsTo("parentUUID") String parentUUID,
final @MapsTo("candidate") Node candidate); AddDockedNodeCommand(final Node parent,
final Node candidate); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); Node getCandidate(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testInitializeCommands() { this.tested = spy(tested); tested.initialize(graphCommandExecutionContext); ArgumentCaptor<Command> commandArgumentCaptor = ArgumentCaptor.forClass(Command.class); verify(tested, times(2)).addCommand(commandArgumentCaptor.capture()); List<Command> commands = commandArgumentCaptor.getAllValues(); assertNotNull(commands); assertTrue(commands.size() == 2); assertTrue(commands.get(0) instanceof RegisterNodeCommand); assertTrue(commands.get(1) instanceof DockNodeCommand); } |
### Question:
AddNodeCommand extends RegisterNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { final SafeDeleteNodeCommand undoCommand = new SafeDeleteNodeCommand(getCandidate()); return undoCommand.execute(context); } AddNodeCommand(final @MapsTo("candidate") Node candidate); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testUndo() { CommandResult<RuleViolation> result = tested.undo(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); verify(graph, times(1)).removeNode(eq(UUID)); verify(graphIndex, times(1)).removeNode(eq(node)); verify(graphIndex, times(0)).removeEdge(any(Edge.class)); verify(graph, times(0)).addNode(eq(node)); verify(graphIndex, times(0)).addNode(eq(node)); verify(graphIndex, times(0)).addEdge(any(Edge.class)); } |
### Question:
AddControlPointCommand extends AbstractControlPointCommand { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext context) { checkAddControlPoint(getEdgeControlPoints(context).getControlPoints(), controlPoint, index); return GraphCommandResultBuilder.SUCCESS; } AddControlPointCommand(final @MapsTo("edgeUUID") String edgeUUID,
final @MapsTo("controlPoint") ControlPoint controlPoint,
final @MapsTo("index") int index); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); }### Answer:
@Test public void testCheck() { tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, 0); CommandResult<RuleViolation> result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, 1); result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, 2); result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, 3); result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidIndex() { tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, -1); tested.check(graphCommandExecutionContext); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndex() { tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, 4); tested.check(graphCommandExecutionContext); }
@Test(expected = IllegalArgumentException.class) public void testInvalidCP() { tested = new AddControlPointCommand(EDGE_UUID, newControlPoint, 2); newControlPoint.setLocation(null); tested.check(graphCommandExecutionContext); } |
### Question:
UpdateDomainObjectPropertyValueCommand extends AbstractGraphCommand { @Override @SuppressWarnings("unchecked") public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final DefinitionManager definitionManager = context.getDefinitionManager(); final Object p = definitionManager.adapters().forDefinition().getProperty(domainObject, field).get(); final AdapterManager adapterManager = definitionManager.adapters(); final AdapterRegistry adapterRegistry = adapterManager.registry(); final PropertyAdapter<Object, Object> adapter = (PropertyAdapter<Object, Object>) adapterRegistry.getPropertyAdapter(p.getClass()); oldValue = adapter.getValue(p); adapter.setValue(p, value); return GraphCommandResultBuilder.SUCCESS; } UpdateDomainObjectPropertyValueCommand(final @MapsTo("domainObject") DomainObject domainObject,
final @MapsTo("field") String field,
final @MapsTo("value") Object value); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { assertEquals(CommandResult.Type.INFO, command.execute(graphCommandExecutionContext).getType()); verify(propertyAdapter).getValue(eq(domainObject.getNameProperty())); verify(propertyAdapter).setValue(eq(domainObject.getNameProperty()), eq(PROPERTY_VALUE)); } |
### Question:
UpdateDomainObjectPropertyValueCommand extends AbstractGraphCommand { @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { final UpdateDomainObjectPropertyValueCommand undoCommand = new UpdateDomainObjectPropertyValueCommand(domainObject, field, oldValue); return undoCommand.execute(context); } UpdateDomainObjectPropertyValueCommand(final @MapsTo("domainObject") DomainObject domainObject,
final @MapsTo("field") String field,
final @MapsTo("value") Object value); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testUndo() { command.execute(graphCommandExecutionContext); verify(propertyAdapter).getValue(eq(domainObject.getNameProperty())); verify(propertyAdapter).setValue(eq(domainObject.getNameProperty()), eq(PROPERTY_VALUE)); assertEquals(CommandResult.Type.INFO, command.undo(graphCommandExecutionContext).getType()); verify(propertyAdapter, times(2)).getValue(eq(domainObject.getNameProperty())); verify(propertyAdapter).setValue(eq(domainObject.getNameProperty()), eq(PROPERTY_OLD_VALUE)); } |
### Question:
SafeDeleteNodeCommand extends AbstractGraphCompositeCommand { public Optional<SafeDeleteNodeCommandCallback> getSafeDeleteCallback() { return safeDeleteCallback; } SafeDeleteNodeCommand(final @MapsTo("candidateUUID") String candidateUUID,
final @MapsTo("options") Options options); SafeDeleteNodeCommand(final Node<?, Edge> node); SafeDeleteNodeCommand(final Node<?, Edge> node,
final Options options); SafeDeleteNodeCommand(final Node<?, Edge> node,
final SafeDeleteNodeCommandCallback safeDeleteCallback,
final Options options); Optional<SafeDeleteNodeCommandCallback> getSafeDeleteCallback(); boolean shouldKeepChildren(final Node<Definition<?>, Edge> candidate); GraphsProvider getGraphsProvider(); Node<?, Edge> getNode(); Options getOptions(); @Override String toString(); }### Answer:
@Test public void testGetSafeDeleteCallback() { final Node node = mock(Node.class); when(node.getUUID()).thenReturn("uuid"); final SafeDeleteNodeCommand.SafeDeleteNodeCommandCallback callback = mock(SafeDeleteNodeCommand.SafeDeleteNodeCommandCallback.class); final SafeDeleteNodeCommand command = new SafeDeleteNodeCommand(node, callback, SafeDeleteNodeCommand.Options.defaults()); final Optional<SafeDeleteNodeCommand.SafeDeleteNodeCommandCallback> actual = command.getSafeDeleteCallback(); assertTrue(actual.isPresent()); assertEquals(callback, actual.get()); } |
### Question:
SafeDeleteNodeCommand extends AbstractGraphCompositeCommand { void createChangeParentCommands(final Element<?> canvas, final Node<?, Edge> candidate) { final List<Node> childNodes = GraphUtils.getChildNodes(candidate); for (final Node n : childNodes) { safeDeleteCallback.ifPresent(c -> c.moveChildToCanvasRoot(canvas.asNode(), n)); } } SafeDeleteNodeCommand(final @MapsTo("candidateUUID") String candidateUUID,
final @MapsTo("options") Options options); SafeDeleteNodeCommand(final Node<?, Edge> node); SafeDeleteNodeCommand(final Node<?, Edge> node,
final Options options); SafeDeleteNodeCommand(final Node<?, Edge> node,
final SafeDeleteNodeCommandCallback safeDeleteCallback,
final Options options); Optional<SafeDeleteNodeCommandCallback> getSafeDeleteCallback(); boolean shouldKeepChildren(final Node<Definition<?>, Edge> candidate); GraphsProvider getGraphsProvider(); Node<?, Edge> getNode(); Options getOptions(); @Override String toString(); }### Answer:
@Test public void testCreateChangeParentCommands() { final Node node = mock(Node.class); final SafeDeleteNodeCommand.SafeDeleteNodeCommandCallback callback = mock(SafeDeleteNodeCommand.SafeDeleteNodeCommandCallback.class); final Element<?> canvas = mock(Element.class); final Node canvasNode = mock(Node.class); final Node<?, Edge> candidate = mock(Node.class); final List<Edge> outEdges = new ArrayList<>(); final Edge e1 = mock(Edge.class); final Child child = mock(Child.class); final Node targetNode = mock(Node.class); when(node.getUUID()).thenReturn("uuid"); when(canvas.asNode()).thenReturn(canvasNode); when(e1.getContent()).thenReturn(child); when(e1.getTargetNode()).thenReturn(targetNode); when(candidate.getOutEdges()).thenReturn(outEdges); outEdges.add(e1); final SafeDeleteNodeCommand command = new SafeDeleteNodeCommand(node, callback, SafeDeleteNodeCommand.Options.defaults()); command.createChangeParentCommands(canvas, candidate); verify(callback).moveChildToCanvasRoot(canvasNode, targetNode); } |
### Question:
DeleteControlPointCommand extends AbstractControlPointCommand { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext context) { checkDeleteControlPoint(getEdgeControlPoints(context).getControlPoints(), index); return GraphCommandResultBuilder.SUCCESS; } DeleteControlPointCommand(final @MapsTo("edgeUUID") String edgeUUID,
final @MapsTo("index") int index); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); }### Answer:
@Test public void testChecks() { tested = new DeleteControlPointCommand(EDGE_UUID, 0); CommandResult<RuleViolation> result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); tested = new DeleteControlPointCommand(EDGE_UUID, 1); result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); tested = new DeleteControlPointCommand(EDGE_UUID, 2); result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testInvalidIndex() { tested = new DeleteControlPointCommand(EDGE_UUID, -1); tested.check(graphCommandExecutionContext); }
@Test(expected = IllegalArgumentException.class) public void testIndexForbidden() { tested = new DeleteControlPointCommand(EDGE_UUID, 3); tested.check(graphCommandExecutionContext); } |
### Question:
RemoveChildrenCommand extends AbstractGraphCommand { @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final CommandResult<RuleViolation> results = allow(context); if (!results.getType().equals(CommandResult.Type.ERROR)) { final Node<?, Edge> parent = getParent(context); getCandidates(context).forEach(candidate -> removeChild(context, parent, candidate)); } return results; } RemoveChildrenCommand(final @MapsTo("parentUUID") String parentUUID,
final @MapsTo("candidateUUIDs") String[] candidateUUIDs); RemoveChildrenCommand(final Node<?, Edge> parent,
final Node<?, Edge> candidate); RemoveChildrenCommand(final Node<?, Edge> parent,
final Collection<Node<?, Edge>> candidates); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); Node<?, Edge> getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); assertTrue(parentOutEdges.isEmpty()); assertTrue(candidateInEdges.isEmpty()); verify(graphIndex, times(1)).removeEdge(any(Edge.class)); verify(graphIndex, times(0)).removeNode(any(Node.class)); verify(graph, times(0)).addNode(any(Node.class)); verify(graphIndex, times(0)).addNode(any(Node.class)); verify(graphIndex, times(0)).addEdge(any(Edge.class)); } |
### Question:
AddConnectorCommand extends AbstractGraphCompositeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { getMutableIndex(context).addEdge(edge); final CommandResult<RuleViolation> results = super.execute(context); if (CommandUtils.isError(results)) { getMutableIndex(context).removeEdge(edge); } return results; } AddConnectorCommand(final @MapsTo("nodeUUID") String nodeUUID,
final @MapsTo("edge") Edge edge,
final @MapsTo("magnet") Connection connection); AddConnectorCommand(final Node<?, Edge> sourceNode,
final Edge edge,
final Connection connection); @Override CommandResult<RuleViolation> allow(final GraphCommandExecutionContext context); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); Edge getEdge(); Connection getConnection(); Node<?, Edge> getSourceNode(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); assertTrue(node.getOutEdges().size() == 1); assertEquals(edge, node.getOutEdges().get(0)); verify(graphIndex, times(1)).addEdge(eq(edge)); verify(graphIndex, times(0)).addNode(any(Node.class)); } |
### Question:
DeleteNodeCommand extends DeregisterNodeCommand { @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { final AddNodeCommand undoCommand = new AddNodeCommand(getRemoved()); return undoCommand.execute(context); } DeleteNodeCommand(final @MapsTo("uuid") String uuid); DeleteNodeCommand(final Node<?, Edge> node); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testUndo() { tested.removed = node; CommandResult<RuleViolation> result = tested.undo(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); verify(graph, times(2)).addNode(any(Node.class)); verify(graphIndex, times(1)).addNode(any(Node.class)); verify(graph, times(0)).removeNode(eq(UUID)); verify(graphIndex, times(0)).removeNode(eq(node)); verify(graphIndex, times(0)).removeEdge(any(Edge.class)); verify(graphIndex, times(0)).addEdge(any(Edge.class)); } |
### Question:
CloneConnectorCommand extends AbstractGraphCompositeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { return new DeleteConnectorCommand(clone).execute(context); } CloneConnectorCommand(); CloneConnectorCommand(final @MapsTo("candidate") Edge candidate, final @MapsTo("sourceNodeUUID") String sourceNodeUUID, final @MapsTo("targetNodeUUID") String targetNodeUUID); CloneConnectorCommand(Edge candidate, String sourceNodeUUID, String targetNodeUUID, Consumer<Edge> callback); @Override CommandResult<RuleViolation> execute(GraphCommandExecutionContext context); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); }### Answer:
@Test public void undo() throws Exception { cloneConnectorCommand.execute(graphCommandExecutionContext); cloneConnectorCommand.undo(graphCommandExecutionContext); verify(graphIndex, times(1)).removeEdge(cloneEdge); } |
### Question:
UpdateElementPositionCommand extends AbstractGraphCommand { public Node<?, Edge> getNode() { return node; } UpdateElementPositionCommand(final @MapsTo("uuid") String uuid,
final @MapsTo("location") Point2D location,
final @MapsTo("previousLocation") Point2D previousLocation); UpdateElementPositionCommand(final Node<? extends View<?>, Edge> node,
final Point2D location); Point2D getLocation(); Point2D getPreviousLocation(); Node<?, Edge> getNode(); String getUuid(); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); static Bounds computeCandidateBounds(final Element<? extends View<?>> element,
final Point2D location); @Override String toString(); }### Answer:
@Test(expected = BadCommandArgumentsException.class) public void testAllowNodeNotFound() { this.tested = new UpdateElementPositionCommand(UUID, LOCATION, PREVIOUS_LOCATION); when(graphIndex.getNode(eq(UUID))).thenReturn(null); tested.allow(graphCommandExecutionContext); } |
### Question:
RemoveParentCommand extends AbstractGraphCommand { @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final CommandResult<RuleViolation> results = allow(context); if (!results.getType().equals(CommandResult.Type.ERROR)) { final Node<?, Edge> parent = getParent(context); final Node<?, Edge> candidate = getCandidate(context); final Edge<Parent, Node> edge = getEdgeForTarget(parent, candidate); if (null != edge) { edge.setSourceNode(null); edge.setTargetNode(null); parent.getInEdges().remove(edge); candidate.getOutEdges().remove(edge); getMutableIndex(context).removeEdge(edge); } } return results; } RemoveParentCommand(final @MapsTo("parentUUID") String parentUUID,
final @MapsTo("candidateUUID") String candidateUUID); RemoveParentCommand(final Node<?, Edge> parent,
final Node<?, Edge> candidate); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); assertTrue(parentInEdges.isEmpty()); assertTrue(candidateOutEdges.isEmpty()); verify(graphIndex, times(1)).removeEdge(any(Edge.class)); verify(graphIndex, times(0)).removeNode(any(Node.class)); verify(graph, times(0)).addNode(any(Node.class)); verify(graphIndex, times(0)).addNode(any(Node.class)); verify(graphIndex, times(0)).addEdge(any(Edge.class)); } |
### Question:
UpdateElementPropertyValueCommand extends AbstractGraphCommand { @Override @SuppressWarnings("unchecked") public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final Element<Definition<?>> element = (Element<Definition<?>>) getNullSafeElement(context); final Object p = context.getDefinitionManager().adapters().forDefinition().getProperty(element.getContent().getDefinition(), field).get(); final PropertyAdapter<Object, Object> adapter = (PropertyAdapter<Object, Object>) context.getDefinitionManager().adapters().registry().getPropertyAdapter(p.getClass()); oldValue = adapter.getValue(p); adapter.setValue(p, value); return GraphCommandResultBuilder.SUCCESS; } UpdateElementPropertyValueCommand(final @MapsTo("elementUUID") String elementUUID,
final @MapsTo("field") String field,
final @MapsTo("value") Object value); UpdateElementPropertyValueCommand(final Element<?> element,
final String propertyId,
final Object value); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); Object getOldValue(); String getField(); Object getValue(); Element<?> getElement(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); ArgumentCaptor<Bounds> bounds = ArgumentCaptor.forClass(Bounds.class); assertEquals(CommandResult.Type.INFO, result.getType()); assertEquals(PROPERTY_OLD_VALUE, tested.getOldValue()); verify(propertyAdapter, times(1)).getValue(eq(property)); verify(propertyAdapter, times(1)).setValue(eq(property), eq(PROPERTY_VALUE)); }
@Test(expected = BadCommandArgumentsException.class) public void testExecuteNodeNotFound() { when(graphIndex.get(eq(UUID))).thenReturn(null); tested.execute(graphCommandExecutionContext); } |
### Question:
UpdateControlPointPositionCommand extends AbstractControlPointCommand { @Override protected CommandResult<RuleViolation> check(final GraphCommandExecutionContext context) { checkUpdateControlPoint(getEdgeControlPoints(context).getControlPoints(), controlPoints); return GraphCommandResultBuilder.SUCCESS; } UpdateControlPointPositionCommand(final @MapsTo("edgeUUID") String edgeUUID,
final @MapsTo("controlPoints") ControlPoint[] controlPoints); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); }### Answer:
@Test public void testCheck() { tested = new UpdateControlPointPositionCommand(EDGE_UUID, newControlPoints); CommandResult<RuleViolation> result = tested.check(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); }
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPs() { newControlPoints = new ControlPoint[]{newControlPoint1, newControlPoint2}; tested = new UpdateControlPointPositionCommand(EDGE_UUID, newControlPoints); tested.check(graphCommandExecutionContext); }
@Test(expected = IllegalArgumentException.class) public void testCannotUpdateCPs2() { when(viewConnector.getControlPoints()).thenReturn(new ControlPoint[]{controlPoint1, controlPoint2}); tested = new UpdateControlPointPositionCommand(EDGE_UUID, newControlPoints); tested.check(graphCommandExecutionContext); } |
### Question:
UpdateControlPointPositionCommand extends AbstractControlPointCommand { @Override public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final HasControlPoints hasControlPoints = getEdgeControlPoints(context); oldControlPoints = hasControlPoints.getControlPoints(); hasControlPoints.setControlPoints(controlPoints); return SUCCESS; } UpdateControlPointPositionCommand(final @MapsTo("edgeUUID") String edgeUUID,
final @MapsTo("controlPoints") ControlPoint[] controlPoints); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); }### Answer:
@Test public void testUpdateControlPoints() { tested = new UpdateControlPointPositionCommand(EDGE_UUID, newControlPoints); CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); assertFalse(CommandUtils.isError(result)); ArgumentCaptor<ControlPoint[]> pointsCaptor = ArgumentCaptor.forClass(ControlPoint[].class); verify(viewConnector, times(1)).setControlPoints(pointsCaptor.capture()); ControlPoint[] controlPoints = pointsCaptor.getValue(); assertNotNull(controlPoints); assertEquals(3, controlPoints.length); assertEquals(newControlPoint1, controlPoints[0]); assertEquals(newControlPoint2, controlPoints[1]); assertEquals(newControlPoint3, controlPoints[2]); } |
### Question:
ClearGraphCommand extends AbstractGraphCommand { @Override @SuppressWarnings("unchecked") public CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context) { final CommandResult<RuleViolation> results = allow(context); if (!results.getType().equals(CommandResult.Type.ERROR)) { final Graph<?, Node> graph = getGraph(context); if (hasRootUUID()) { Iterator<Node> nodes = graph.nodes().iterator(); if (null != nodes) { nodes.forEachRemaining(node -> { if (!node.getUUID().equals(rootUUID)) { getMutableIndex(context).removeNode(node); nodes.remove(); } else { node.getOutEdges().stream().forEach(edge -> getMutableIndex(context).removeEdge((Edge) edge)); node.getOutEdges().clear(); } }); } } else { graph.clear(); getMutableIndex(context).clear(); } } return results; } ClearGraphCommand(final @MapsTo("rootUUID") String rootUUID); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); String getRootUUID(); @Override String toString(); }### Answer:
@Test public void testExecute() { CommandResult<RuleViolation> result = tested.execute(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); verify(graph, times(1)).clear(); verify(graphIndex, times(1)).clear(); } |
### Question:
ClearGraphCommand extends AbstractGraphCommand { @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { throw new UnsupportedOperationException("Undo operation for Clear Graph Command is still not supported. "); } ClearGraphCommand(final @MapsTo("rootUUID") String rootUUID); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); String getRootUUID(); @Override String toString(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testUndo() { tested.undo(graphCommandExecutionContext); } |
### Question:
SetConnectionSourceNodeCommand extends AbstractGraphCommand { @SuppressWarnings("unchecked") public Node<? extends View<?>, Edge> getSourceNode(final GraphCommandExecutionContext context) { if (null == sourceNode) { sourceNode = (Node<? extends View<?>, Edge>) getNode(context, sourceNodeUUID); } return sourceNode; } @SuppressWarnings("unchecked") SetConnectionSourceNodeCommand(final @MapsTo("sourceNodeUUID") String sourceNodeUUID,
final @MapsTo("edgeUUID") String edgeUUID,
final @MapsTo("magnet") Connection connection); @SuppressWarnings("unchecked") SetConnectionSourceNodeCommand(final Node<? extends View<?>, Edge> sourceNode,
final Edge<? extends View, Node> edge,
final Connection connection); @SuppressWarnings("unchecked") SetConnectionSourceNodeCommand(final Node<? extends View<?>, Edge> sourceNode,
final Edge<? extends View, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @SuppressWarnings("unchecked") Node<? extends View<?>, Edge> getTargetNode(final GraphCommandExecutionContext context); @SuppressWarnings("unchecked") Node<? extends View<?>, Edge> getSourceNode(final GraphCommandExecutionContext context); Edge<? extends View, Node> getEdge(final GraphCommandExecutionContext context); Node<? extends View<?>, Edge> getSourceNode(); Edge<? extends View, Node> getEdge(); Node<? extends View<?>, Edge> getTargetNode(); Connection getConnection(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSkipRulesForSameSourceNodeAsBefore() { when(edge.getSourceNode()).thenReturn(node); CommandResult<RuleViolation> result = tested.allow(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); verify(ruleManager, times(0)).evaluate(eq(ruleSet), any(RuleEvaluationContext.class)); } |
### Question:
CloneNodeCommand extends AbstractGraphCompositeCommand { @Override protected boolean delegateRulesContextToChildren() { return false; } protected CloneNodeCommand(); CloneNodeCommand(final @MapsTo("candidate") Node candidate, final @MapsTo("parentUuid") String parentUuid); CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D position, final Consumer<Node> callback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D position, final Consumer<Node> callback); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); List<CommandResult<RuleViolation>> processChildrenNodes(GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(GraphCommandExecutionContext context); Node<View, Edge> getClone(); Node<Definition, Edge> getCandidate(); List<Command<GraphCommandExecutionContext, RuleViolation>> getChildrenCommands(); }### Answer:
@Test public void testDelegateRulesContextToChildren() throws Exception { assertFalse(cloneNodeCommand.delegateRulesContextToChildren()); } |
### Question:
CloneNodeCommand extends AbstractGraphCompositeCommand { @Override public CommandResult<RuleViolation> undo(GraphCommandExecutionContext context) { return new SafeDeleteNodeCommand(clone).execute(context); } protected CloneNodeCommand(); CloneNodeCommand(final @MapsTo("candidate") Node candidate, final @MapsTo("parentUuid") String parentUuid); CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D position, final Consumer<Node> callback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D position, final Consumer<Node> callback); @Override CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); List<CommandResult<RuleViolation>> processChildrenNodes(GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(GraphCommandExecutionContext context); Node<View, Edge> getClone(); Node<Definition, Edge> getCandidate(); List<Command<GraphCommandExecutionContext, RuleViolation>> getChildrenCommands(); }### Answer:
@Test public void testUndo() throws Exception { testInitialize(); cloneNodeCommand.undo(graphCommandExecutionContext); verify(graphIndex, times(1)).removeNode(clone); } |
### Question:
MorphNodeCommand extends AbstractGraphCommand { @Override public CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context) { final MorphNodeCommand undoCommand = new MorphNodeCommand(uuid, morphDefinition, oldMorphTarget); return undoCommand.execute(context); } MorphNodeCommand(final @MapsTo("uuid") String uuid,
final @MapsTo("morphDefinition") MorphDefinition morphDefinition,
final @MapsTo("morphTarget") String morphTarget); MorphNodeCommand(final Node<Definition, Edge> candidate,
final MorphDefinition morphDefinition,
final String morphTarget); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testUndo() { tested.execute(graphCommandExecutionContext); reset(content); when(content.getDefinition()).thenReturn(NEW_DEFINITION); CommandResult<RuleViolation> result = tested.undo(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); verify(content).setDefinition(eq(CURRENT_DEFINITION)); assertEquals(1, labels.size()); assertTrue(labels.contains(CURRENT_DEFINITION_ID)); } |
### Question:
SetConnectionTargetNodeCommand extends AbstractGraphCommand { @SuppressWarnings("unchecked") private Node<? extends View<?>, Edge> getTargetNode(final GraphCommandExecutionContext context) { if (null == targetNode) { targetNode = (Node<? extends View<?>, Edge>) getNode(context, targetNodeUUID); } return targetNode; } @SuppressWarnings("unchecked") SetConnectionTargetNodeCommand(final @MapsTo("targetNodeUUID") String targetNodeUUID,
final @MapsTo("edgeUUID") String edgeUUID,
final @MapsTo("magnet") Connection connection); @SuppressWarnings("unchecked") SetConnectionTargetNodeCommand(final Node<? extends View<?>, Edge> targetNode,
final Edge<? extends View, Node> edge,
final Connection connection); @SuppressWarnings("unchecked") SetConnectionTargetNodeCommand(final Node<? extends View<?>, Edge> targetNode,
final Edge<? extends View, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> execute(final GraphCommandExecutionContext context); @Override @SuppressWarnings("unchecked") CommandResult<RuleViolation> undo(final GraphCommandExecutionContext context); Edge<? extends View, Node> getEdge(); Connection getConnection(); Node<? extends View<?>, Edge> getTargetNode(); Node<? extends View<?>, Edge> getSourceNode(); @Override String toString(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testSkipRulesForSameTargetNodeAsBefore() { when(edge.getTargetNode()).thenReturn(node); CommandResult<RuleViolation> result = tested.allow(graphCommandExecutionContext); assertEquals(CommandResult.Type.INFO, result.getType()); verify(ruleManager, times(0)).evaluate(eq(ruleSet), any(RuleEvaluationContext.class)); } |
### Question:
MagnetConnection extends DiscreteConnection { @Override public Point2D getLocation() { return location; } private MagnetConnection(final @MapsTo("location") Point2D location,
final @MapsTo("auto") Boolean auto); private MagnetConnection(int index); MagnetConnection setLocation(final Point2D location); MagnetConnection setAuto(final boolean auto); @Override Point2D getLocation(); boolean isAuto(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final int MAGNET_CENTER; static final int MAGNET_TOP; static final int MAGNET_RIGHT; static final int MAGNET_BOTTOM; static final int MAGNET_LEFT; }### Answer:
@Test public void testForLocation() { MagnetConnection m1 = MagnetConnection.Builder.at(123, 321); assertEquals(123, m1.getLocation().getX(), 0); assertEquals(321, m1.getLocation().getY(), 0); } |
### Question:
JsConverter { public static KeyValue[] fromMap(Map map) { return fromEntries(map.entrySet()); } static KeyValue[] fromMap(Map map); static KeyValue[] fromEntries(Collection<Map.Entry> entries); }### Answer:
@Test public void fromMap() { final Map<?, ?> map = new Maps.Builder<String, String>() .put("name", "tiago") .put("age", "34") .build(); final KeyValue[] keyValues = JsConverter.fromMap(map); assertEquals(keyValues.length, 2); assertEquals(keyValues[0].getKey(), "name"); assertEquals(keyValues[0].getValue(), "tiago"); assertEquals(keyValues[1].getKey(), "age"); assertEquals(keyValues[1].getValue(), "34"); } |
### Question:
NoneCloneProcess implements CloneProcess { @Override public <T> T clone(T source) { return source; } @Override T clone(T source); @Override T clone(S source, T target); }### Answer:
@Test public void testClone() throws Exception { Object clone = noneCloneProcess.clone(def1); assertEquals(clone, def1); }
@Test public void testCloneParam() throws Exception { Object clone = noneCloneProcess.clone(def1, def2); assertEquals(clone, def2); assertNotEquals(clone, def1); } |
### Question:
DeepCloneProcess extends AbstractCloneProcess implements IDeepCloneProcess { @Override @SuppressWarnings("all") public <S, T> T clone(final S source, final T target) { final AdapterRegistry adapters = adapterManager.registry(); final DefinitionAdapter<Object> sourceDefinitionAdapter = adapters.getDefinitionAdapter(source.getClass()); for (String field : sourceDefinitionAdapter.getPropertyFields(source)) { Optional<?> property = sourceDefinitionAdapter.getProperty(source, field); property.ifPresent(p -> { final Object value = adapters.getPropertyAdapter(p.getClass()).getValue(p); if (null != value && isAllowedToClone(value)) { Optional<?> targetProperty = adapters.getDefinitionAdapter(target.getClass()).getProperty(target, field); targetProperty.ifPresent(tp -> { final PropertyAdapter tpa = adapters.getPropertyAdapter(tp.getClass()); tpa.setValue(tp, value); }); } }); } return target; } protected DeepCloneProcess(); @Inject DeepCloneProcess(final FactoryManager factoryManager,
final AdapterManager adapterManager,
final ClassUtils classUtils); @Override @SuppressWarnings("all") T clone(final S source,
final T target); }### Answer:
@Test public void testClone() throws Exception { Object clone = deepCloneProcess.clone(def1); testPropertySet(clone, def1, nameProperty2, nameValue); testPropertySet(clone, def1, textProperty2, textValue); testPropertySet(clone, def1, booleanProperty2, booleanValue); } |
### Question:
CloneManagerImpl implements CloneManager { @Override public <T> T clone(T source, ClonePolicy policy) { return cloneProcess(policy).clone(source); } CloneManagerImpl(); @Inject CloneManagerImpl(IDeepCloneProcess deepCloneProcess, DefaultCloneProcess defaultCloneProcess, NoneCloneProcess noneCloneProcess); @Override T clone(T source, ClonePolicy policy); @Override T clone(S source, T target, ClonePolicy policy); }### Answer:
@Test public void testClone() throws Exception { cloneManager.clone(def1, ClonePolicy.ALL); verify(deepCloneProcess, times(1)).clone(def1); cloneManager.clone(def1, ClonePolicy.DEFAULT); verify(defaultCloneProcess, times(1)).clone(def1); cloneManager.clone(def1, ClonePolicy.NONE); verify(noneCloneProcess, times(1)).clone(def1); }
@Test(expected = NullPointerException.class) public void testCloneNullPolicy() { cloneManager.clone(def1, null); }
@Test public void testCloneParam() throws Exception { cloneManager.clone(def1, def2, ClonePolicy.ALL); verify(deepCloneProcess, times(1)).clone(def1, def2); cloneManager.clone(def1, def2, ClonePolicy.DEFAULT); verify(defaultCloneProcess, times(1)).clone(def1, def2); cloneManager.clone(def1, def2, ClonePolicy.NONE); verify(noneCloneProcess, times(1)).clone(def1, def2); } |
### Question:
DefaultCloneProcess extends AbstractCloneProcess { @Override public <S, T> T clone(S source, T target) { final DefinitionAdapter<Object> definitionAdapter = adapterManager.forDefinition(); final String namePropertyField = definitionAdapter.getMetaPropertyField(source, PropertyMetaTypes.NAME); final String targetNamePropertyField = definitionAdapter.getMetaPropertyField(target, PropertyMetaTypes.NAME); final Object nameProperty = definitionAdapter.getProperty(source, namePropertyField).get(); final Object targetNameProperty = definitionAdapter.getProperty(target, targetNamePropertyField).get(); final Object namePropertyValue = adapterManager.forProperty().getValue(nameProperty); adapterManager.forProperty().setValue(targetNameProperty, namePropertyValue); return target; } DefaultCloneProcess(); @Inject DefaultCloneProcess(FactoryManager factoryManager, AdapterManager adapterManager); @Override T clone(S source, T target); }### Answer:
@Test(expected = NullPointerException.class) public void testCloneNull() throws Exception { defaultCloneProcess.clone(null); }
@Test public void testClone() throws Exception { Object clone = defaultCloneProcess.clone(def1); testPropertySet(clone, def1, nameProperty2, nameValue); }
@Test public void testCloneParam() throws Exception { Object clone = defaultCloneProcess.clone(def1, def3); testPropertySet(clone, def1, nameProperty3, nameValue); } |
### Question:
BindablePropertyAdapterImpl implements BindablePropertyAdapter<T, R> { @Override public String getId(T pojo) { return BindableAdapterUtils.getPropertyId(pojo.getClass()); } private BindablePropertyAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); @Override void addBinding(Class<?> type, String valueField); @Override String getId(T pojo); @Override String getCaption(T pojo); @Override R getValue(T pojo); @Override void setValue(T pojo, R value); @Override int getPriority(); @Override boolean accepts(Class<?> type); }### Answer:
@Test public void testGetId() { String id1 = tested.getId(PROPERTY_1); assertEquals(BindableTestProperty1.class.getName(), id1); String id2 = tested.getId(PROPERTY_2); assertEquals(BindableTestProperty2.class.getName(), id2); } |
### Question:
BindablePropertyAdapterImpl implements BindablePropertyAdapter<T, R> { @Override public String getCaption(T pojo) { return translationService.getPropertyCaption(getId(pojo)); } private BindablePropertyAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); @Override void addBinding(Class<?> type, String valueField); @Override String getId(T pojo); @Override String getCaption(T pojo); @Override R getValue(T pojo); @Override void setValue(T pojo, R value); @Override int getPriority(); @Override boolean accepts(Class<?> type); }### Answer:
@Test public void testGetCaption() { when(translationService.getPropertyCaption(BindableTestProperty1.class.getName())) .thenReturn("p1"); when(translationService.getPropertyCaption(BindableTestProperty2.class.getName())) .thenReturn("p2"); String caption1 = tested.getCaption(PROPERTY_1); String caption2 = tested.getCaption(PROPERTY_2); assertEquals("p1", caption1); assertEquals("p2", caption2); } |
### Question:
BindablePropertyAdapterImpl implements BindablePropertyAdapter<T, R> { @Override public R getValue(T pojo) { return getFieldValue(pojo, valueFields.get(pojo.getClass())); } private BindablePropertyAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); @Override void addBinding(Class<?> type, String valueField); @Override String getId(T pojo); @Override String getCaption(T pojo); @Override R getValue(T pojo); @Override void setValue(T pojo, R value); @Override int getPriority(); @Override boolean accepts(Class<?> type); }### Answer:
@Test public void testGetValue() { when(functions.getValue(PROPERTY_1, "value")).thenReturn("p1Value"); when(functions.getValue(PROPERTY_2, "someValue")).thenReturn("p2Value"); Object value1 = tested.getValue(PROPERTY_1); Object value2 = tested.getValue(PROPERTY_2); assertEquals("p1Value", value1); assertEquals("p2Value", value2); } |
### Question:
BindablePropertyAdapterImpl implements BindablePropertyAdapter<T, R> { @Override public void setValue(T pojo, R value) { setFieldValue(pojo, valueFields.get(pojo.getClass()), value); } private BindablePropertyAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindablePropertyAdapterImpl<Object, Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, String> valueFields); @Override void addBinding(Class<?> type, String valueField); @Override String getId(T pojo); @Override String getCaption(T pojo); @Override R getValue(T pojo); @Override void setValue(T pojo, R value); @Override int getPriority(); @Override boolean accepts(Class<?> type); }### Answer:
@Test public void testSetValue() { tested.setValue(PROPERTY_1, "newValue1"); tested.setValue(PROPERTY_2, "newValue2"); verify(functions, times(1)).setValue(eq(PROPERTY_1), eq("value"), eq("newValue1")); verify(functions, times(1)).setValue(eq(PROPERTY_2), eq("someValue"), eq("newValue2")); } |
### Question:
BindableDefinitionAdapterImpl implements BindableDefinitionAdapter<T> { @Override public DefinitionId getId(T pojo) { final String fieldId = getBindings(pojo).getIdField(); final String definitionId = getDefinitionId(pojo.getClass()); if (null != fieldId) { final String id = BindableAdapterUtils.getDynamicDefinitionId(definitionId, getFieldValue(pojo, fieldId)); return DefinitionId.build(id, definitionId.length()); } return DefinitionId.build(definitionId); } private BindableDefinitionAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); @Override void addBindings(Class<?> type, DefinitionAdapterBindings bindings); @Override DefinitionId getId(T pojo); @Override String getCategory(T pojo); @Override String getTitle(T pojo); @Override String getDescription(T pojo); @Override @SuppressWarnings("all") String[] getLabels(T pojo); @Override String[] getPropertyFields(T pojo); @Override Optional<?> getProperty(T pojo, String field); @Override String getMetaPropertyField(T pojo, PropertyMetaTypes type); @Override String getBaseType(Class<?> type); @Override String[] getTypes(String baseType); @Override Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactory(Class<?> type); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetId() { DefinitionId id = tested.getId(BEAN1); assertTrue(id.isDynamic()); assertEquals(BEAN1.getClass().getName(), id.value()); } |
### Question:
BindableDefinitionAdapterImpl implements BindableDefinitionAdapter<T> { @Override public String getCategory(T pojo) { return getFieldValue(pojo, bindings.get(pojo.getClass()).getCategoryField()); } private BindableDefinitionAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); @Override void addBindings(Class<?> type, DefinitionAdapterBindings bindings); @Override DefinitionId getId(T pojo); @Override String getCategory(T pojo); @Override String getTitle(T pojo); @Override String getDescription(T pojo); @Override @SuppressWarnings("all") String[] getLabels(T pojo); @Override String[] getPropertyFields(T pojo); @Override Optional<?> getProperty(T pojo, String field); @Override String getMetaPropertyField(T pojo, PropertyMetaTypes type); @Override String getBaseType(Class<?> type); @Override String[] getTypes(String baseType); @Override Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactory(Class<?> type); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetCategory() { when(functions.getValue(eq(BEAN1), eq("categoryField"))).thenReturn("categoryValue"); String category = tested.getCategory(BEAN1); assertEquals("categoryValue", category); } |
### Question:
BindableDefinitionAdapterImpl implements BindableDefinitionAdapter<T> { @Override public String getTitle(T pojo) { String title = getFieldValue(pojo, bindings.get(pojo.getClass()).getTitleField()); if (isEmpty(title)) { return translationService.getDefinitionTitle(pojo.getClass().getName()); } return title; } private BindableDefinitionAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); @Override void addBindings(Class<?> type, DefinitionAdapterBindings bindings); @Override DefinitionId getId(T pojo); @Override String getCategory(T pojo); @Override String getTitle(T pojo); @Override String getDescription(T pojo); @Override @SuppressWarnings("all") String[] getLabels(T pojo); @Override String[] getPropertyFields(T pojo); @Override Optional<?> getProperty(T pojo, String field); @Override String getMetaPropertyField(T pojo, PropertyMetaTypes type); @Override String getBaseType(Class<?> type); @Override String[] getTypes(String baseType); @Override Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactory(Class<?> type); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetTitle() { when(functions.getValue(eq(BEAN1), eq("titleField"))).thenReturn("titleValue"); String title = tested.getTitle(BEAN1); assertEquals("titleValue", title); } |
### Question:
BindableDefinitionAdapterImpl implements BindableDefinitionAdapter<T> { @Override public String getDescription(T pojo) { String description = getFieldValue(pojo, bindings.get(pojo.getClass()).getDescriptionField()); if (isEmpty(description)) { return translationService.getDefinitionDescription(pojo.getClass().getName()); } return description; } private BindableDefinitionAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); @Override void addBindings(Class<?> type, DefinitionAdapterBindings bindings); @Override DefinitionId getId(T pojo); @Override String getCategory(T pojo); @Override String getTitle(T pojo); @Override String getDescription(T pojo); @Override @SuppressWarnings("all") String[] getLabels(T pojo); @Override String[] getPropertyFields(T pojo); @Override Optional<?> getProperty(T pojo, String field); @Override String getMetaPropertyField(T pojo, PropertyMetaTypes type); @Override String getBaseType(Class<?> type); @Override String[] getTypes(String baseType); @Override Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactory(Class<?> type); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetDescription() { when(functions.getValue(eq(BEAN1), eq("descriptionField"))).thenReturn("descriptionValue"); String description = tested.getDescription(BEAN1); assertEquals("descriptionValue", description); } |
### Question:
BindableDefinitionAdapterImpl implements BindableDefinitionAdapter<T> { @Override @SuppressWarnings("all") public Class<? extends ElementFactory> getGraphFactory(Class<?> type) { return (Class<? extends ElementFactory>) bindings.get(type).getGraphFactory(); } private BindableDefinitionAdapterImpl(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions); static BindableDefinitionAdapterImpl<Object> create(StunnerTranslationService translationService,
BindableAdapterFunctions functions,
Map<Class<?>, DefinitionAdapterBindings> bindings); @Override void addBindings(Class<?> type, DefinitionAdapterBindings bindings); @Override DefinitionId getId(T pojo); @Override String getCategory(T pojo); @Override String getTitle(T pojo); @Override String getDescription(T pojo); @Override @SuppressWarnings("all") String[] getLabels(T pojo); @Override String[] getPropertyFields(T pojo); @Override Optional<?> getProperty(T pojo, String field); @Override String getMetaPropertyField(T pojo, PropertyMetaTypes type); @Override String getBaseType(Class<?> type); @Override String[] getTypes(String baseType); @Override Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactory(Class<?> type); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test @SuppressWarnings("all") public void testGetGraphFacotry() { Class<? extends ElementFactory> graphFactory = tested.getGraphFactory(BEAN1.getClass()); assertEquals(NodeFactory.class, graphFactory); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override public String getId(T pojo) { String _id = BindableAdapterUtils.getDefinitionSetId(pojo.getClass()); if (_id.contains("$")) { _id = _id.substring(0, _id.indexOf("$")); } return _id; } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetId() { String id = tested.getId(INSTANCE); assertEquals("org.kie.workbench.common.stunner.core.definition.adapter.binding.BindableDefinitionSetAdapterImplTest", id); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override public String getDomain(T pojo) { return BindableAdapterUtils.getDefinitionSetDomain(pojo.getClass()); } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetDomain() { String domain = tested.getDomain(INSTANCE); assertEquals("org.kie.workbench.common.stunner.core.definition.adapter.binding", domain); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override public String getDescription(T pojo) { String description = translationService.getDefinitionSetDescription(getId(pojo)); return description != null && description.trim().length() > 0 ? description : getId(pojo); } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetDescription() { when(translationService.getDefinitionSetDescription(eq("org.kie.workbench.common.stunner.core.definition.adapter.binding.BindableDefinitionSetAdapterImplTest"))) .thenReturn("defSetDescriptionValue"); String description = tested.getDescription(INSTANCE); assertEquals("defSetDescriptionValue", description); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override @SuppressWarnings("all") public Class<? extends ElementFactory> getGraphFactoryType(T pojo) { return (Class<? extends ElementFactory>) bindings.getGraphFactory(); } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test @SuppressWarnings("all") public void testGetGraphFactory() { Class<? extends ElementFactory> graphFactoryType = tested.getGraphFactoryType(INSTANCE); assertEquals(GraphFactory.class, graphFactoryType); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override public Annotation getQualifier(T pojo) { return bindings.getQualifier(); } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetQualifier() { Annotation qualifier = tested.getQualifier(INSTANCE); assertEquals(QUALIFIER, qualifier); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override public Optional<String> getSvgNodeId(T pojo) { return translationService.getDefinitionSetSvgNodeId(getId(pojo)); } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetSvgNodeId() { when(translationService.getDefinitionSetSvgNodeId(eq("org.kie.workbench.common.stunner.core.definition.adapter.binding.BindableDefinitionSetAdapterImplTest"))) .thenReturn(Optional.of("svg1")); Optional<String> svgNodeId = tested.getSvgNodeId(INSTANCE); assertTrue(svgNodeId.isPresent()); assertEquals("svg1", svgNodeId.get()); } |
### Question:
BindableDefinitionSetAdapterImpl implements BindableDefinitionSetAdapter<T> { @Override public Set<String> getDefinitions(T pojo) { return bindings.getDefinitionIds(); } private BindableDefinitionSetAdapterImpl(StunnerTranslationService translationService); static BindableDefinitionSetAdapterImpl<Object> create(StunnerTranslationService translationService); @Override void setBindings(Class<?> type, DefinitionSetAdapterBindings bindings); @Override String getId(T pojo); @Override String getDomain(T pojo); @Override String getDescription(T pojo); @Override Set<String> getDefinitions(T pojo); @Override @SuppressWarnings("all") Class<? extends ElementFactory> getGraphFactoryType(T pojo); @Override Annotation getQualifier(T pojo); @Override Optional<String> getSvgNodeId(T pojo); @Override boolean accepts(Class<?> type); @Override int getPriority(); }### Answer:
@Test public void testGetDefinitions() { Set<String> definitions = tested.getDefinitions(INSTANCE); assertEquals(2, definitions.size()); assertTrue(definitions.contains("def1")); assertTrue(definitions.contains("def2")); } |
### Question:
DomainLookupsCache { public String getDefinitionSetId() { return defSetId; } DomainLookupsCache(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry definitionsRegistry,
final String defSetId); Set<String> getDefinitions(final String label); void clear(); String getDefinitionSetId(); List<CanConnect> getConnectionRules(); RuleSet getRuleSet(); }### Answer:
@Test public void testGetDefinitionSetId() { assertEquals(DEF_SET_ID, tested.getDefinitionSetId()); } |
### Question:
DomainLookupsCache { public List<CanConnect> getConnectionRules() { return connectionRules; } DomainLookupsCache(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry definitionsRegistry,
final String defSetId); Set<String> getDefinitions(final String label); void clear(); String getDefinitionSetId(); List<CanConnect> getConnectionRules(); RuleSet getRuleSet(); }### Answer:
@Test public void testCacheTheConnectionRules() { List<CanConnect> rules = tested.getConnectionRules(); assertEquals(1, rules.size()); assertEquals(canConnect1To2, rules.get(0)); } |
### Question:
DomainLookupsCache { public Set<String> getDefinitions(final String label) { final Set<String> ids = definitionsByLabel.get(label); return null != ids ? ids : Collections.emptySet(); } DomainLookupsCache(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry definitionsRegistry,
final String defSetId); Set<String> getDefinitions(final String label); void clear(); String getDefinitionSetId(); List<CanConnect> getConnectionRules(); RuleSet getRuleSet(); }### Answer:
@Test public void testGetDefinitionsByLabel() { assertEquals(Collections.emptySet(), tested.getDefinitions("SOMETHING_NOT_EXISTING")); Set<String> defs1 = tested.getDefinitions(ROLE1); assertEquals(1, defs1.size()); assertEquals(DEF_ID1, defs1.iterator().next()); Set<String> defs2 = tested.getDefinitions(ROLE2); assertEquals(1, defs2.size()); assertEquals(DEF_ID2, defs2.iterator().next()); } |
### Question:
DomainLookupFunctions { public static boolean isSourceConnectionAllowed(final CanConnect rule, final Set<String> labels) { return rule.getPermittedConnections().stream() .anyMatch(pc -> labels.contains(pc.getStartRole())); } static boolean isSourceConnectionAllowed(final CanConnect rule,
final Set<String> labels); }### Answer:
@Test public void testIsSourceConnectionAllowed() { assertTrue(isSourceConnectionAllowed(permittedConnections, new HashSet<String>(1) {{ add(ROLE1); }})); assertTrue(isSourceConnectionAllowed(permittedConnections, new HashSet<String>(1) {{ add(ROLE2); }})); assertFalse(isSourceConnectionAllowed(permittedConnections, new HashSet<String>(1) {{ add(ROLE3); }})); } |
### Question:
CommonDomainLookups { @PreDestroy public void destroy() { if (null != cache) { cache.clear(); cache = null; } } @Inject CommonDomainLookups(final DefinitionUtils definitionUtils,
final DefinitionsCacheRegistry definitionsRegistry,
final RuleManager ruleManager); CommonDomainLookups(final DefinitionUtils definitionUtils,
final DefinitionsCacheRegistry definitionsRegistry,
final RuleManager ruleManager,
final Function<String, DomainLookupsCache> cacheBuilder); CommonDomainLookups setDomain(final String defSetId); Set<String> lookupTargetConnectors(final Node<? extends Definition<Object>, ? extends Edge> sourceNode); Set<String> lookupTargetNodes(final Graph<?, ? extends Node> graph,
final Node<? extends Definition<Object>, ? extends Edge> sourceNode,
final String edgeId); Set<String> lookupTargetNodes(final Graph<?, ? extends Node> graph,
final Node<? extends Definition<Object>, ? extends Edge> sourceNode,
final String edgeId,
final Predicate<String> definitionIdsAllowedFilter); Set<String> lookupMorphBaseDefinitions(final Set<String> definitionIds); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.setDomain("someDomain"); tested.destroy(); verify(cache, times(1)).clear(); assertNull(tested.getCache()); } |
### Question:
AbstractCriteriaLookupManager extends AbstractLookupManager<I, T, R> { protected Collection<String> toCollection(final String s) { if (s != null && !s.startsWith(COLLECTION_START_CHAR)) { return new HashSet<>(0); } else if (s != null && s.startsWith(COLLECTION_START_CHAR) && s.endsWith(COLLECTION_END_CHAR)) { final String toParse = s.substring(1, s.length() - 1); final String[] parsed = toParse.split(COLLECTION_DELIMITER); final HashSet<String> result = new HashSet<>(parsed.length); for (String p : parsed) { result.add(p.trim()); } return result; } return new HashSet<>(0); } static Map<String, String> parseCriteria(final String criteria); static String[] parseCriteriaPair(final String criteria); }### Answer:
@Test public void checkToSet_NullSet() { assertEquals(Collections.emptySet(), manager.toCollection(null)); }
@Test public void checkToSet_EmptySet() { assertEquals(Collections.emptySet(), manager.toCollection("")); }
@Test public void checkToSet_NoCollectionDelimiters() { assertEquals(Collections.emptySet(), manager.toCollection("label")); }
@Test public void checkToSet_NoCollectionStartDelimiter() { assertEquals(Collections.emptySet(), manager.toCollection("label]")); }
@Test public void checkToSet_NoCollectionEndDelimiter() { assertEquals(Collections.emptySet(), manager.toCollection("[label")); }
@Test public void checkToSet_SingleValue() { final Collection<String> set = manager.toCollection("[label1]"); assertEquals(1, set.size()); assertTrue(set.stream().anyMatch(s -> s.equals("label1"))); }
@Test public void checkToSet_MultipleValues() { final Collection<String> set = manager.toCollection("[label1,label2]"); assertEquals(2, set.size()); assertTrue(set.stream().anyMatch(s -> s.equals("label1"))); assertTrue(set.stream().anyMatch(s -> s.equals("label2"))); } |
### Question:
DocumentationPage extends PageImpl { @Override public void onFocus() { onFocus.execute(); view.refresh(); } DocumentationPage(DocumentationView view, String label, Command onFocus, Supplier<Boolean> isSelected); @Override void onFocus(); DocumentationView getDocumentationView(); }### Answer:
@Test public void onFocus() { tested.onFocus(); verify(focus).execute(); } |
### Question:
ClientTranslationService extends AbstractTranslationService { @Override public Optional<String> getElementName(final String uuid) { return getNameProvider(uuid) .map(nameProvider -> nameProvider.getElementName(uuid)) .orElse(Optional.of(defaultElementName(uuid))); } @Inject ClientTranslationService(final TranslationService erraiTranslationService,
final ManagedInstance<DiagramElementNameProvider> elementNameProviders,
final SessionManager sessionManager,
final DefinitionUtils definitionUtils); @Override String getValue(final String key); String getNotNullValue(final String key); @Override String getValue(final String key,
final Object... args); @Override String getViolationMessage(final RuleViolation ruleViolation); @Override Optional<String> getElementName(final String uuid); }### Answer:
@Test public void getElementName() { final Optional<String> elementName = tested.getElementName(UUID); assertTrue(elementName.isPresent()); assertEquals(NAME, elementName.get()); }
@Test public void getElementNameNull() { final Optional<String> elementName = tested.getElementName("unknown"); assertFalse(elementName.isPresent()); } |
### Question:
ConnectorProxy implements ShapeProxy { @PostConstruct public void init() { proxy .setView(view) .setProxyBuilder(this::onCreateProxy); } @Inject ConnectorProxy(final ElementProxy proxy,
final ShapeProxyView<EdgeShape> view); @PostConstruct void init(); ConnectorProxy setCanvasHandler(final AbstractCanvasHandler canvasHandler); ConnectorProxy setEdge(final Edge<? extends ViewConnector<?>, Node> edge); ConnectorProxy setSourceNode(final Node<? extends View<?>, Edge> sourceNode); ConnectorProxy start(final AbstractMouseEvent event); @Override void start(final double x,
final double y); @Override void destroy(); }### Answer:
@Test public void testInit() { tested.init(); verify(proxy, times(1)).setView(eq(view)); verify(proxy, times(1)).setProxyBuilder(any()); } |
### Question:
ConnectorProxy implements ShapeProxy { public ConnectorProxy start(final AbstractMouseEvent event) { start(event.getX(), event.getY()); return this; } @Inject ConnectorProxy(final ElementProxy proxy,
final ShapeProxyView<EdgeShape> view); @PostConstruct void init(); ConnectorProxy setCanvasHandler(final AbstractCanvasHandler canvasHandler); ConnectorProxy setEdge(final Edge<? extends ViewConnector<?>, Node> edge); ConnectorProxy setSourceNode(final Node<? extends View<?>, Edge> sourceNode); ConnectorProxy start(final AbstractMouseEvent event); @Override void start(final double x,
final double y); @Override void destroy(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testStart() { CanvasCommand<AbstractCanvasHandler> command = mock(CanvasCommand.class); doReturn(command).when(commandFactory).addConnector(eq(sourceNode), eq(edge), any(MagnetConnection.class), eq(SHAPE_SET_ID)); double x = 1d; double y = 2d; tested.init(); tested.start(x, y); verify(proxy, times(1)).start(eq(x), eq(y)); EdgeShape edgeShape = view.getShapeBuilder().get(); assertEquals(connector, edgeShape); verify(proxy, times(1)).execute(eq(command)); } |
### Question:
ConnectorProxy implements ShapeProxy { @Override public void destroy() { proxy.destroy(); edge = null; sourceNode = null; } @Inject ConnectorProxy(final ElementProxy proxy,
final ShapeProxyView<EdgeShape> view); @PostConstruct void init(); ConnectorProxy setCanvasHandler(final AbstractCanvasHandler canvasHandler); ConnectorProxy setEdge(final Edge<? extends ViewConnector<?>, Node> edge); ConnectorProxy setSourceNode(final Node<? extends View<?>, Edge> sourceNode); ConnectorProxy start(final AbstractMouseEvent event); @Override void start(final double x,
final double y); @Override void destroy(); }### Answer:
@Test public void testDestroy() { tested.init(); tested.destroy(); verify(proxy, times(1)).destroy(); } |
### Question:
NodeProxy implements ShapeProxy { @PostConstruct public void init() { proxy .setView(view) .setProxyBuilder(this::onCreateProxy); } @Inject NodeProxy(final ElementProxy proxy,
final ShapeProxyView<NodeShape> view); @PostConstruct void init(); NodeProxy setCanvasHandler(final AbstractCanvasHandler canvasHandler); NodeProxy setTargetNode(Node<View<?>, Edge> targetNode); NodeProxy setEdge(Edge<ViewConnector<?>, Node> edge); NodeProxy setSourceNode(Node<View<?>, Edge> sourceNode); NodeProxy start(final AbstractMouseEvent event); @Override void start(final double x,
final double y); @Override void destroy(); }### Answer:
@Test public void testInit() { tested.init(); verify(proxy, times(1)).setView(eq(view)); verify(proxy, times(1)).setProxyBuilder(any()); } |
### Question:
NodeProxy implements ShapeProxy { @Override public void destroy() { proxy.destroy(); targetNode = null; edge = null; sourceNode = null; } @Inject NodeProxy(final ElementProxy proxy,
final ShapeProxyView<NodeShape> view); @PostConstruct void init(); NodeProxy setCanvasHandler(final AbstractCanvasHandler canvasHandler); NodeProxy setTargetNode(Node<View<?>, Edge> targetNode); NodeProxy setEdge(Edge<ViewConnector<?>, Node> edge); NodeProxy setSourceNode(Node<View<?>, Edge> sourceNode); NodeProxy start(final AbstractMouseEvent event); @Override void start(final double x,
final double y); @Override void destroy(); }### Answer:
@Test public void testDestroy() { tested.init(); tested.destroy(); verify(proxy, times(1)).destroy(); } |
### Question:
ElementProxy implements ShapeProxy { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return commandManager.execute(canvasHandler, command); } @Inject ElementProxy(final SessionCommandManager<AbstractCanvasHandler> commandManager,
final Event<CanvasSelectionEvent> selectionEvent,
final @Any ManagedInstance<DefaultCanvasCommandFactory> commandFactories,
final DefinitionUtils definitionUtils); @SuppressWarnings("unchecked") ElementProxy setView(final ShapeProxyView<? extends ElementShape> view); ElementProxy setProxyBuilder(final Supplier<ElementShape> proxyBuilder); ElementProxy setCanvasHandler(final AbstractCanvasHandler canvasHandler); @Override void start(final double x,
final double y); @Override void destroy(); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); Canvas getCanvas(); AbstractCanvasHandler getCanvasHandler(); }### Answer:
@Test @SuppressWarnings("unchecked") public void testExecute() { Command c = mock(Command.class); tested.execute(c); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(c)); verify(commandManager, never()).allow(any(), any()); } |
### Question:
LayoutHelper { public void applyLayout(final Diagram diagram, final LayoutExecutor layoutExecutor) { applyLayout(diagram, layoutExecutor, false); } @Inject LayoutHelper(final LayoutService layoutService); void applyLayout(final Diagram diagram, final LayoutExecutor layoutExecutor); void applyLayout(final Diagram diagram,
final LayoutExecutor layoutExecutor,
final boolean overrideCurrentLayout); LayoutService getLayoutService(); }### Answer:
@Test public void applyLayout() { final LayoutHelper helper = new LayoutHelper(layoutService); helper.applyLayout(diagram, layoutExecutor); verify(rootNodeContent).setBounds(argumentCaptor.capture()); final Bounds bounds = argumentCaptor.getValue(); isCloseToZero(bounds.getLowerRight()); isCloseToZero(bounds.getUpperLeft()); }
@Test public void applyLayoutDoNotOverrideExistingLayout() { when(layoutService.hasLayoutInformation(graph)).thenReturn(true); final LayoutHelper helper = new LayoutHelper(layoutService); helper.applyLayout(diagram, layoutExecutor, false); verify(layoutExecutor, never()).applyLayout(any(), any()); }
@Test public void applyLayoutOverrideExistingLayout() { when(layoutService.hasLayoutInformation(graph)).thenReturn(true); final LayoutHelper helper = new LayoutHelper(layoutService); helper.applyLayout(diagram, layoutExecutor, true); verify(layoutExecutor).applyLayout(any(), any()); } |
### Question:
UndoableLayoutExecutor implements LayoutExecutor { @SuppressWarnings("Duplicates") @Override public void applyLayout(final Layout layout, final Graph graph) { if (layout.getNodePositions().size() == 0) { return; } final CompositeCommand command = createCommand(layout, graph); commandManager.execute(canvasHandler, command); } UndoableLayoutExecutor(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager); @SuppressWarnings("Duplicates") @Override void applyLayout(final Layout layout, final Graph graph); AbstractCanvasHandler getCanvasHandler(); CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); }### Answer:
@Test public void testApplyLayout() { executor.applyLayout(layout, graph); verify(executor).createCommand(layout, graph); verify(commandManager).execute(any(), any()); } |
### Question:
UndoableLayoutExecutor implements LayoutExecutor { CompositeCommand createCommand(final Layout layout, final Graph graph) { final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<>(); for (int i = 0; i < layout.getNodePositions().size(); i++) { final VertexPosition position = layout.getNodePositions().get(i); final Node node = graph.getNode(position.getId()); commandBuilder.addCommand(new UpdateElementPositionCommand(node, position.getUpperLeft())); } return commandBuilder.build(); } UndoableLayoutExecutor(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager); @SuppressWarnings("Duplicates") @Override void applyLayout(final Layout layout, final Graph graph); AbstractCanvasHandler getCanvasHandler(); CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); }### Answer:
@Test public void testCreateCommand() { executor.createCommand(layout, graph); verify(fakeList).get(0); verify(fakeList).get(1); verify(graph, times(2)).getNode("id"); } |
### Question:
CollapsedPaletteDefinitionBuilder extends AbstractPaletteDefinitionBuilder<CollapsedPaletteDefinitionBuilder> { @Override protected DefaultPaletteItem createItem(final Object definition, final String categoryId, final Metadata metadata, final Function<String, DefaultPaletteItem> itemSupplier) { final DefinitionAdapter<Object> definitionAdapter = getDefinitionManager().adapters().forDefinition(); final String id = definitionAdapter.getId(definition).value(); final String title = definitionAdapter.getTitle(definition); return new CollapsedItemBuilder() .setItemId(id) .setDefinitionId(id) .setTooltip(title) .build(); } @Inject CollapsedPaletteDefinitionBuilder(final DefinitionUtils definitionUtils,
final DomainProfileManager profileManager,
final DefinitionsCacheRegistry definitionsRegistry,
final StunnerTranslationService translationService); }### Answer:
@Test public void testCreateItem() { DefaultPaletteItem item = tested.createItem(definition1, DEF1_CATEGORY, metadata, itemSupplier); assertNotNull(item); assertEquals(DEF1_ID, item.getId()); assertEquals(DEF1_ID, item.getDefinitionId()); assertEquals(DEF1_TITLE, item.getTitle()); assertEquals(DEF1_TITLE, item.getTooltip()); assertEquals(DEF1_TITLE, item.getDescription()); assertEquals(DefaultPaletteDefinitionBuilders.CollapsedItemBuilder.ICON_SIZE, item.getIconSize()); } |
### Question:
CanvasDefinitionTooltip implements CanvasTooltip<CanvasDefinitionTooltip.DefinitionIdContent> { @Override public void setCanvasLocation(final Point2D location) { this.textTooltip.setCanvasLocation(location); } @Inject CanvasDefinitionTooltip(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry registry,
final CanvasTooltip<String> textTooltip); CanvasDefinitionTooltip(final CanvasTooltip<String> textTooltip,
final Function<String, String> titleProvider); CanvasDefinitionTooltip setPrefix(final String value); CanvasDefinitionTooltip configure(final AbstractCanvasHandler canvasHandler); @Override void setCanvasLocation(final Point2D location); @Override void setTransform(Transform transform); @Override void show(final DefinitionIdContent content,
final Point2D location); void show(final String definitionId,
final Point2D location); @Override void hide(); void destroy(); }### Answer:
@Test public void testSetCanvasLocation() { final Point2D point = new Point2D(22, 66); tested.setCanvasLocation(point); verify(textTooltip, times(1)).setCanvasLocation(eq(point)); } |
### Question:
CanvasDefinitionTooltip implements CanvasTooltip<CanvasDefinitionTooltip.DefinitionIdContent> { @Override public void setTransform(Transform transform) { this.textTooltip.setTransform(transform); } @Inject CanvasDefinitionTooltip(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry registry,
final CanvasTooltip<String> textTooltip); CanvasDefinitionTooltip(final CanvasTooltip<String> textTooltip,
final Function<String, String> titleProvider); CanvasDefinitionTooltip setPrefix(final String value); CanvasDefinitionTooltip configure(final AbstractCanvasHandler canvasHandler); @Override void setCanvasLocation(final Point2D location); @Override void setTransform(Transform transform); @Override void show(final DefinitionIdContent content,
final Point2D location); void show(final String definitionId,
final Point2D location); @Override void hide(); void destroy(); }### Answer:
@Test public void testSetTransform() { final Transform transform = mock(Transform.class); tested.setTransform(transform); verify(textTooltip, times(1)).setTransform(eq(transform)); } |
### Question:
CanvasDefinitionTooltip implements CanvasTooltip<CanvasDefinitionTooltip.DefinitionIdContent> { @Override public void show(final DefinitionIdContent content, final Point2D location) { this.show(content.id, location); } @Inject CanvasDefinitionTooltip(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry registry,
final CanvasTooltip<String> textTooltip); CanvasDefinitionTooltip(final CanvasTooltip<String> textTooltip,
final Function<String, String> titleProvider); CanvasDefinitionTooltip setPrefix(final String value); CanvasDefinitionTooltip configure(final AbstractCanvasHandler canvasHandler); @Override void setCanvasLocation(final Point2D location); @Override void setTransform(Transform transform); @Override void show(final DefinitionIdContent content,
final Point2D location); void show(final String definitionId,
final Point2D location); @Override void hide(); void destroy(); }### Answer:
@Test public void testShow() { final Point2D point = new Point2D(55, 6); tested.show(new CanvasDefinitionTooltip.DefinitionIdContent("def1"), point); verify(textTooltip, times(1)).show(eq("def1theTestTitle"), eq(point)); verify(textTooltip, never()).hide(); verify(textTooltip, never()).destroy(); } |
### Question:
CanvasDefinitionTooltip implements CanvasTooltip<CanvasDefinitionTooltip.DefinitionIdContent> { @Override public void hide() { textTooltip.hide(); } @Inject CanvasDefinitionTooltip(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry registry,
final CanvasTooltip<String> textTooltip); CanvasDefinitionTooltip(final CanvasTooltip<String> textTooltip,
final Function<String, String> titleProvider); CanvasDefinitionTooltip setPrefix(final String value); CanvasDefinitionTooltip configure(final AbstractCanvasHandler canvasHandler); @Override void setCanvasLocation(final Point2D location); @Override void setTransform(Transform transform); @Override void show(final DefinitionIdContent content,
final Point2D location); void show(final String definitionId,
final Point2D location); @Override void hide(); void destroy(); }### Answer:
@Test public void testHide() { tested.hide(); verify(textTooltip, times(1)).hide(); verify(textTooltip, never()).show(anyString(), any(Point2D.class)); } |
### Question:
CanvasDefinitionTooltip implements CanvasTooltip<CanvasDefinitionTooltip.DefinitionIdContent> { public void destroy() { textTooltip.destroy(); } @Inject CanvasDefinitionTooltip(final DefinitionManager definitionManager,
final DefinitionsCacheRegistry registry,
final CanvasTooltip<String> textTooltip); CanvasDefinitionTooltip(final CanvasTooltip<String> textTooltip,
final Function<String, String> titleProvider); CanvasDefinitionTooltip setPrefix(final String value); CanvasDefinitionTooltip configure(final AbstractCanvasHandler canvasHandler); @Override void setCanvasLocation(final Point2D location); @Override void setTransform(Transform transform); @Override void show(final DefinitionIdContent content,
final Point2D location); void show(final String definitionId,
final Point2D location); @Override void hide(); void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(textTooltip, times(1)).destroy(); verify(textTooltip, never()).show(anyString(), any(Point2D.class)); } |
### Question:
FlowActionsToolboxFactory extends AbstractActionsToolboxFactory { @PreDestroy public void destroy() { createConnectorActions.destroyAll(); createNodeActions.destroyAll(); views.destroyAll(); } @Inject FlowActionsToolboxFactory(final DefinitionUtils definitionUtils,
final ToolboxDomainLookups toolboxDomainLookups,
final DomainProfileManager profileManager,
final @Any ManagedInstance<CreateConnectorToolboxAction> createConnectorActions,
final @Any @FlowActionsToolbox ManagedInstance<CreateNodeToolboxAction> createNodeActions,
final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxView> views); @Override @SuppressWarnings("unchecked") Collection<ToolboxAction<AbstractCanvasHandler>> getActions(final AbstractCanvasHandler canvasHandler,
final Element<?> element); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(createConnectorActions, times(1)).destroyAll(); verify(createNodeActions, times(1)).destroyAll(); verify(views, times(1)).destroyAll(); } |
### Question:
MorphActionsToolboxFactory extends AbstractActionsToolboxFactory { @PreDestroy public void destroy() { morphNodeActionsDestroyer.execute(); viewsDestroyer.execute(); } @Inject MorphActionsToolboxFactory(final DefinitionUtils definitionUtils,
final DomainProfileManager profileManager,
final @Any ManagedInstance<MorphNodeToolboxAction> morphNodeActions,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxView> views); MorphActionsToolboxFactory(final DefinitionUtils definitionUtils,
final DomainProfileManager profileManager,
final Supplier<MorphNodeToolboxAction> morphNodeActions,
final Command morphNodeActionsDestroyer,
final Supplier<ActionsToolboxView> views,
final Command viewsDestroyer); @Override @SuppressWarnings("unchecked") Collection<ToolboxAction<AbstractCanvasHandler>> getActions(final AbstractCanvasHandler canvasHandler,
final Element<?> e); @PreDestroy void destroy(); }### Answer:
@Test public void testDestroy() { tested.destroy(); verify(morphNodeActionDestroyer, times(1)).execute(); verify(viewDestroyer, times(1)).execute(); } |
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { public ActionsToolbox<V> init() { getView().init(this); return this; } ActionsToolbox(final Supplier<AbstractCanvasHandler> canvasHandlerSupplier,
final Element<?> element,
final V view); ActionsToolbox<V> init(); ActionsToolbox add(final ToolboxAction<AbstractCanvasHandler> action); @Override Iterator<ToolboxAction> iterator(); int size(); String getElementUUID(); AbstractCanvasHandler getCanvasHandler(); AbstractCanvas getCanvas(); Shape<?> getShape(); @Override ActionsToolbox show(); @Override ActionsToolbox hide(); @Override void destroy(); @Override void hideAndDestroy(); V getView(); Glyph getGlyph(final ToolboxAction<AbstractCanvasHandler> action); String getTitle(final ToolboxAction<AbstractCanvasHandler> action); }### Answer:
@Test @SuppressWarnings("unchecked") public void testInit() { tested.init(); verify(view, times(1)).init(eq(tested)); } |
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { @Override public ActionsToolbox show() { if (lastToolBoxRendered.equals(this.uuid)) { return this; } lastToolBoxRendered = this.uuid; getView().show(); return this; } ActionsToolbox(final Supplier<AbstractCanvasHandler> canvasHandlerSupplier,
final Element<?> element,
final V view); ActionsToolbox<V> init(); ActionsToolbox add(final ToolboxAction<AbstractCanvasHandler> action); @Override Iterator<ToolboxAction> iterator(); int size(); String getElementUUID(); AbstractCanvasHandler getCanvasHandler(); AbstractCanvas getCanvas(); Shape<?> getShape(); @Override ActionsToolbox show(); @Override ActionsToolbox hide(); @Override void destroy(); @Override void hideAndDestroy(); V getView(); Glyph getGlyph(final ToolboxAction<AbstractCanvasHandler> action); String getTitle(final ToolboxAction<AbstractCanvasHandler> action); }### Answer:
@Test public void testShow() { tested.show(); verify(view, times(1)).show(); }
@Test public void testShowOnlyOnce() { tested.show(); tested.show(); verify(view, times(1)).show(); } |
### Question:
ActionsToolbox implements Toolbox<ActionsToolbox>,
Iterable<ToolboxAction> { @Override public ActionsToolbox hide() { getView().hide(); return this; } ActionsToolbox(final Supplier<AbstractCanvasHandler> canvasHandlerSupplier,
final Element<?> element,
final V view); ActionsToolbox<V> init(); ActionsToolbox add(final ToolboxAction<AbstractCanvasHandler> action); @Override Iterator<ToolboxAction> iterator(); int size(); String getElementUUID(); AbstractCanvasHandler getCanvasHandler(); AbstractCanvas getCanvas(); Shape<?> getShape(); @Override ActionsToolbox show(); @Override ActionsToolbox hide(); @Override void destroy(); @Override void hideAndDestroy(); V getView(); Glyph getGlyph(final ToolboxAction<AbstractCanvasHandler> action); String getTitle(final ToolboxAction<AbstractCanvasHandler> action); }### Answer:
@Test public void testHide() { tested.hide(); verify(view, times(1)).hide(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.