Ignore:
Timestamp:
2016-07-28T01:24:39+02:00 (8 years ago)
Author:
Don-vip
Message:

fix #13223 - Minor command class fixes (patch by michael2402, modified) - gsoc-core

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/test/unit/org/openstreetmap/josm/command/DeleteCommandTest.java

    r9943 r10663  
    22package org.openstreetmap.josm.command;
    33
    4 import org.junit.BeforeClass;
     4import static org.junit.Assert.assertArrayEquals;
     5import static org.junit.Assert.assertEquals;
     6import static org.junit.Assert.assertFalse;
     7import static org.junit.Assert.assertTrue;
     8
     9import java.util.ArrayList;
     10import java.util.Arrays;
     11import java.util.Collection;
     12import java.util.List;
     13
     14import org.junit.Before;
     15import org.junit.Rule;
    516import org.junit.Test;
    6 import org.openstreetmap.josm.JOSMFixture;
     17import org.openstreetmap.josm.command.CommandTest.CommandTestDataWithRelation;
    718import org.openstreetmap.josm.data.osm.DataSet;
     19import org.openstreetmap.josm.data.osm.Node;
     20import org.openstreetmap.josm.data.osm.OsmPrimitive;
     21import org.openstreetmap.josm.data.osm.Relation;
    822import org.openstreetmap.josm.data.osm.User;
     23import org.openstreetmap.josm.data.osm.Way;
     24import org.openstreetmap.josm.data.osm.WaySegment;
    925import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    10 
     26import org.openstreetmap.josm.testutils.JOSMTestRules;
     27
     28import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
    1129import nl.jqno.equalsverifier.EqualsVerifier;
    1230import nl.jqno.equalsverifier.Warning;
    … …  
    1836
    1937    /**
    20      * Setup test.
    21      */
    22     @BeforeClass
    23     public static void setUpBeforeClass() {
    24         JOSMFixture.createUnitTestFixture().init(false);
     38     * We need prefs for nodes.
     39     */
     40    @Rule
     41    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
     42    public JOSMTestRules test = new JOSMTestRules().preferences().i18n();
     43    private CommandTestDataWithRelation testData;
     44
     45    /**
     46     * Set up the test data.
     47     */
     48    @Before
     49    public void createTestData() {
     50        testData = new CommandTestDataWithRelation();
     51    }
     52
     53    /**
     54     * A simple deletion test with no references
     55     */
     56    @Test
     57    public void testSimpleDelete() {
     58        Node node = testData.createNode(15);
     59        assertTrue(testData.layer.data.allPrimitives().contains(node));
     60
     61        new DeleteCommand(node).executeCommand();
     62
     63        assertTrue(node.isDeleted());
     64        assertTrue(node.isModified());
     65        assertFalse(testData.layer.data.allNonDeletedPrimitives().contains(node));
     66    }
     67
     68    /**
     69     * A delete should not delete refered objects but should should remove the reference.
     70     */
     71    @Test
     72    public void testDeleteIgnoresReferences() {
     73        assertTrue(testData.existingNode.getReferrers().contains(testData.existingRelation));
     74        new DeleteCommand(testData.existingRelation).executeCommand();
     75
     76        assertTrue(testData.existingRelation.isDeleted());
     77        assertEquals(0, testData.existingRelation.getMembersCount());
     78        assertFalse(testData.existingNode.isDeleted());
     79        assertFalse(testData.existingWay.isDeleted());
     80        assertFalse(testData.existingNode.getReferrers().contains(testData.existingRelation));
     81
     82        // same for the way
     83        assertTrue(testData.existingNode.getReferrers().contains(testData.existingWay));
     84        new DeleteCommand(testData.existingWay).executeCommand();
     85        assertEquals(0, testData.existingWay.getNodesCount());
     86        assertFalse(testData.existingNode.getReferrers().contains(testData.existingWay));
     87    }
     88
     89    /**
     90     * A delete should delete all objects with references to the deleted one
     91     */
     92    @Test(expected = IllegalArgumentException.class)
     93    public void testDeleteFailsOnDelted() {
     94        new DeleteCommand(testData.existingRelation).executeCommand();
     95
     96        new DeleteCommand(testData.existingRelation).executeCommand();
     97    }
     98
     99    /**
     100     * A delete should delete all objects with references to the deleted one
     101     */
     102    @Test
     103    public void testReferedDelete() {
     104        DeleteCommand.deleteWithReferences(testData.layer, Arrays.asList(testData.existingNode), true).executeCommand();
     105
     106        assertTrue(testData.existingNode.isDeleted());
     107        assertEquals(0, testData.existingWay.getNodesCount());
     108        assertTrue(testData.existingWay.isDeleted());
     109    }
     110
     111    /**
     112     * Delete nodes that would be without reference afterwards.
     113     */
     114    @Test
     115    public void testDelteNodesInWay() {
     116        testData.existingNode.removeAll();
     117        // That untagged node should be deleted.
     118        testData.existingNode2.removeAll();
     119        DeleteCommand.delete(testData.layer, Arrays.asList(testData.existingWay), true, true).executeCommand();
     120
     121        assertTrue(testData.existingWay.isDeleted());
     122        assertTrue(testData.existingNode2.isDeleted());
     123        assertFalse(testData.existingNode.isDeleted());
     124        assertFalse(testData.existingRelation.isDeleted());
     125
     126        // Same test, now with tagged nodes
     127        Node node1 = testData.createNode(15);
     128        Node node2 = testData.createNode(16);
     129        Node node3 = testData.createNode(17);
     130        Node node4 = testData.createNode(18);
     131        node2.removeAll();
     132        node4.removeAll();
     133        Way way1 = new Way(25, 1);
     134        way1.setNodes(Arrays.asList(node1, node2, node3));
     135        testData.layer.data.addPrimitive(way1);
     136        Way way2 = new Way(26, 1);
     137        way2.setNodes(Arrays.asList(node2, node3, node4));
     138        testData.layer.data.addPrimitive(way2);
     139        DeleteCommand.delete(testData.layer, Arrays.asList(way1, way2), true, true).executeCommand();
     140
     141        assertTrue(way1.isDeleted());
     142        assertTrue(way2.isDeleted());
     143        assertFalse(node1.isDeleted());
     144        assertTrue(node2.isDeleted());
     145        assertFalse(node3.isDeleted());
     146        assertTrue(node4.isDeleted());
     147    }
     148
     149    /**
     150     * Test that {@link DeleteCommand} checks for non-null.
     151     */
     152    @Test(expected = IllegalArgumentException.class)
     153    public void testConsistency() {
     154        new DeleteCommand(Arrays.asList(testData.existingNode, testData.existingWay, null));
     155    }
     156
     157    /**
     158     * Test that {@link DeleteCommand} checks for the dataset
     159     */
     160    @Test(expected = IllegalArgumentException.class)
     161    public void testConsistencyDataset() {
     162        testData.layer.data.removePrimitive(testData.existingNode);
     163        new DeleteCommand(Arrays.asList(testData.existingNode, testData.existingWay));
     164    }
     165
     166    /**
     167     * Test that {@link DeleteCommand} checks for non-empty list
     168     */
     169    @Test(expected = IllegalArgumentException.class)
     170    public void testConsistencyNonEmpty() {
     171        new DeleteCommand(Arrays.<OsmPrimitive>asList());
     172    }
     173
     174    /**
     175     * Test that {@link DeleteCommand} checks for non-null list
     176     */
     177    @Test(expected = IllegalArgumentException.class)
     178    public void testConsistencyNonNull() {
     179        new DeleteCommand((Collection<OsmPrimitive>) null);
     180    }
     181
     182    /**
     183     * Test {@link DeleteCommand#undoCommand()}
     184     */
     185    @Test
     186    public void testUndo() {
     187        DeleteCommand command = new DeleteCommand(
     188                Arrays.asList(testData.existingNode, testData.existingNode2, testData.existingWay));
     189        command.executeCommand();
     190
     191        assertTrue(testData.existingNode.isDeleted());
     192        assertTrue(testData.existingWay.isDeleted());
     193
     194        command.undoCommand();
     195
     196        assertFalse(testData.existingNode.isDeleted());
     197        assertFalse(testData.existingWay.isDeleted());
     198        assertEquals("existing", testData.existingNode.get("existing"));
     199
     200        command.executeCommand();
     201
     202        assertTrue(testData.existingNode.isDeleted());
     203        assertTrue(testData.existingWay.isDeleted());
     204    }
     205
     206    /**
     207     * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
     208     * Way with only 1 segment
     209     */
     210    @Test
     211    public void testDeleteWaySegment() {
     212        Way way1 = testData.createWay(100, testData.createNode(101), testData.createNode(102));
     213        WaySegment ws = new WaySegment(way1, 0);
     214        Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
     215        command.executeCommand();
     216
     217        assertTrue(way1.isDeleted());
     218    }
     219
     220    /**
     221     * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
     222     * Delete end of way
     223     */
     224    @Test
     225    public void testDeleteWaySegmentEndOfWay() {
     226        Way way = testData.createWay(200, testData.createNode(201), testData.createNode(202), testData.createNode(203),
     227                testData.createNode(204));
     228        WaySegment ws = new WaySegment(way, 2);
     229        Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
     230        command.executeCommand();
     231
     232        assertEquals(3, way.getNodesCount());
     233        assertEquals(201, way.getNodeId(0));
     234        assertEquals(202, way.getNodeId(1));
     235        assertEquals(203, way.getNodeId(2));
     236    }
     237
     238    /**
     239     * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
     240     * Delete start of way
     241     */
     242    @Test
     243    public void testDeleteWaySegmentStartOfWay() {
     244        Way way = testData.createWay(100, testData.createNode(101), testData.createNode(102), testData.createNode(103),
     245                testData.createNode(104));
     246        WaySegment ws = new WaySegment(way, 0);
     247        Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
     248        command.executeCommand();
     249
     250        assertEquals(3, way.getNodesCount());
     251        assertEquals(102, way.getNodeId(0));
     252        assertEquals(103, way.getNodeId(1));
     253        assertEquals(104, way.getNodeId(2));
     254    }
     255
     256    /**
     257     * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
     258     * Delete start of way
     259     */
     260    @Test
     261    public void testDeleteWaySegmentSplit() {
     262        Node node103 = testData.createNode(103);
     263        Node node104 = testData.createNode(104);
     264        Way way = testData.createWay(100, testData.createNode(101), testData.createNode(102), node103, node104);
     265        WaySegment ws = new WaySegment(way, 1);
     266        Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
     267        command.executeCommand();
     268
     269        assertEquals(2, way.getNodesCount());
     270        assertEquals(101, way.getNodeId(0));
     271        assertEquals(102, way.getNodeId(1));
     272        // there needs to be a new way
     273        assertEquals(1, node104.getReferrers().size());
     274        Way newWay = (Way) node104.getReferrers().get(0);
     275        assertEquals(2, newWay.getNodesCount());
     276        assertEquals(103, newWay.getNodeId(0));
     277        assertEquals(104, newWay.getNodeId(1));
     278    }
     279
     280    /**
     281     * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
     282     * Delete start of way
     283     */
     284    @Test
     285    public void testDeleteWaySegmentCycle() {
     286        Node n = testData.createNode(101);
     287        Way way = testData.createWay(100, n, testData.createNode(102), testData.createNode(103),
     288                testData.createNode(104), n);
     289        WaySegment ws = new WaySegment(way, 2);
     290        Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
     291        command.executeCommand();
     292
     293        assertEquals(4, way.getNodesCount());
     294        assertEquals(104, way.getNodeId(0));
     295        assertEquals(101, way.getNodeId(1));
     296        assertEquals(102, way.getNodeId(2));
     297        assertEquals(103, way.getNodeId(3));
     298    }
     299
     300    /**
     301     * Tests {@link DeleteCommand#getChildren()}
     302     */
     303    @Test
     304    public void testGetChildren() {
     305        testData.existingNode.put("name", "xy");
     306        Collection<PseudoCommand> children = new DeleteCommand(Arrays.<OsmPrimitive>asList(testData.existingNode, testData.existingNode2))
     307                .getChildren();
     308        assertEquals(2, children.size());
     309        assertTrue(children.stream().allMatch(c -> c.getParticipatingPrimitives().size() == 1));
     310        assertTrue(children.stream().anyMatch(c -> c.getParticipatingPrimitives().iterator().next() == testData.existingNode));
     311        assertTrue(children.stream().anyMatch(c -> c.getParticipatingPrimitives().iterator().next() == testData.existingNode2));
     312        assertTrue(children.stream().anyMatch(c -> c.getDescriptionText().matches("Deleted '.*xy.*'")));
     313    }
     314
     315    /**
     316     * Tests {@link DeleteCommand#fillModifiedData(java.util.Collection, java.util.Collection, java.util.Collection)}
     317     */
     318    @Test
     319    public void testFillModifiedData() {
     320        ArrayList<OsmPrimitive> modified = new ArrayList<>();
     321        ArrayList<OsmPrimitive> deleted = new ArrayList<>();
     322        ArrayList<OsmPrimitive> added = new ArrayList<>();
     323        new DeleteCommand(Arrays.<OsmPrimitive>asList(testData.existingNode)).fillModifiedData(modified, deleted, added);
     324        // intentionally left empty.
     325        assertArrayEquals(new Object[] {}, modified.toArray());
     326        assertArrayEquals(new Object[] {}, deleted.toArray());
     327        assertArrayEquals(new Object[] {}, added.toArray());
     328    }
     329
     330    /**
     331     * Tests {@link DeleteCommand#getParticipatingPrimitives()}
     332     */
     333    @Test
     334    public void testGetParticipatingPrimitives() {
     335        DeleteCommand command = new DeleteCommand(Arrays.<OsmPrimitive>asList(testData.existingNode));
     336        assertArrayEquals(new Object[] {testData.existingNode }, command.getParticipatingPrimitives().toArray());
     337
     338        DeleteCommand command2 = new DeleteCommand(
     339                Arrays.<OsmPrimitive>asList(testData.existingNode, testData.existingWay));
     340        assertArrayEquals(new Object[] {testData.existingNode, testData.existingWay},
     341                command2.getParticipatingPrimitives().toArray());
     342    }
     343
     344    /**
     345     * Test {@link DeleteCommand#getDescriptionText()}
     346     */
     347    @Test
     348    public void testDescription() {
     349        Node node = testData.createNode(100);
     350        node.put("name", "xy");
     351        Way way = testData.createWay(101);
     352        way.put("name", "xy");
     353        Relation relation = testData.createRelation(102);
     354        relation.put("name", "xy");
     355
     356        List<OsmPrimitive> nodeList = Arrays.<OsmPrimitive>asList(node);
     357        assertTrue(new DeleteCommand(nodeList).getDescriptionText().matches("Delete node .*xy.*"));
     358        List<OsmPrimitive> wayList = Arrays.<OsmPrimitive>asList(way);
     359        assertTrue(new DeleteCommand(wayList).getDescriptionText().matches("Delete way .*xy.*"));
     360        List<OsmPrimitive> relationList = Arrays.<OsmPrimitive>asList(relation);
     361        assertTrue(new DeleteCommand(relationList).getDescriptionText().matches("Delete relation .*xy.*"));
     362
     363        List<OsmPrimitive> nodesList = Arrays.<OsmPrimitive>asList(node, testData.createNode(110));
     364        assertTrue(new DeleteCommand(nodesList).getDescriptionText().matches("Delete 2 nodes"));
     365        List<OsmPrimitive> waysList = Arrays.<OsmPrimitive>asList(way, testData.createWay(111));
     366        assertTrue(new DeleteCommand(waysList).getDescriptionText().matches("Delete 2 ways"));
     367        List<OsmPrimitive> relationsList = Arrays.<OsmPrimitive>asList(relation, testData.createRelation(112));
     368        assertTrue(new DeleteCommand(relationsList).getDescriptionText().matches("Delete 2 relations"));
     369
     370        List<OsmPrimitive> mixed = Arrays.<OsmPrimitive>asList(node, way, relation);
     371        assertTrue(new DeleteCommand(mixed).getDescriptionText().matches("Delete 3 objects"));
    25372    }
    26373
Note: See TracChangeset for help on using the changeset viewer.