source: josm/trunk/test/unit/org/openstreetmap/josm/data/osm/DataSetTest.java@ 18690

Last change on this file since 18690 was 18690, checked in by taylor.smock, 14 months ago

See #16567: Convert all assertion calls to JUnit 5 (patch by gaben, modified)

The modifications are as follows:

  • Merge DomainValidatorTest.testIDN and DomainValidatorTest.testIDNJava6OrLater
  • Update some tests to use @ParameterizedTest (DomainValidatorTest)
  • Replace various exception blocks with assertThrows. These typically looked like 
        try {
        // Something that should throw an exception here
        fail("An exception should have been thrown");
    } catch (Exception e) {
        // Verify the exception matches expectations here
    }
  • Replace assertTrue(val instanceof Clazz) with assertInstanceOf
  • Replace JUnit 4 @Suite with JUnit 5 @Suite

Both the original patch and the modified patch fix various lint issues.
File size: 13.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.osm;
3
4import static org.junit.jupiter.api.Assertions.assertEquals;
5import static org.junit.jupiter.api.Assertions.assertFalse;
6import static org.junit.jupiter.api.Assertions.assertInstanceOf;
7import static org.junit.jupiter.api.Assertions.assertTrue;
8
9import java.util.ArrayList;
10import java.util.Arrays;
11import java.util.Collections;
12import java.util.HashSet;
13import java.util.List;
14
15import org.junit.jupiter.api.Test;
16import org.junit.jupiter.api.extension.RegisterExtension;
17import org.openstreetmap.josm.TestUtils;
18import org.openstreetmap.josm.data.Bounds;
19import org.openstreetmap.josm.data.DataSource;
20import org.openstreetmap.josm.data.coor.LatLon;
21import org.openstreetmap.josm.data.osm.event.DataSourceAddedEvent;
22import org.openstreetmap.josm.data.osm.event.DataSourceRemovedEvent;
23import org.openstreetmap.josm.testutils.JOSMTestRules;
24
25import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
26
27/**
28 * Unit tests for class {@link DataSet}.
29 */
30class DataSetTest {
31
32 /**
33 * Setup test.
34 */
35 @RegisterExtension
36 @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
37 public JOSMTestRules test = new JOSMTestRules();
38
39 /**
40 * Unit test of method {@link DataSet#searchRelations}.
41 */
42 @Test
43 void testSearchRelations() {
44 final DataSet ds = new DataSet();
45 // null bbox => empty list
46 assertTrue(ds.searchRelations(null).isEmpty(), "Empty data set should produce an empty list.");
47
48 // empty data set, any bbox => empty list
49 BBox bbox = new BBox(new LatLon(-180, -90), new LatLon(180, 90));
50 assertTrue(ds.searchRelations(bbox).isEmpty(), "Empty data set should produce an empty list.");
51
52 // data set with elements in the given bbox => these elements
53 Node node = new Node(LatLon.ZERO);
54 Relation r = new Relation(1);
55 RelationMember rm = new RelationMember("role", node);
56 r.addMember(rm);
57 ds.addPrimitive(node);
58 ds.addPrimitive(r);
59 bbox = new BBox(new LatLon(-1.0, -1.0), new LatLon(1.0, 1.0));
60 List<Relation> result = ds.searchRelations(bbox);
61 assertEquals(1, result.size(), "We should have found only one item.");
62 assertTrue(result.contains(r), "The item found is relation r.");
63 }
64
65 /**
66 * Unit test for {@link DataSet#searchPrimitives}
67 */
68 @Test
69 void testSearchPrimitives() {
70 final DataSet ds = new DataSet();
71 // null bbox => empty list
72 assertTrue(ds.searchPrimitives(null).isEmpty(), "Empty data set should produce an empty list.");
73
74 // empty data set, any bbox => empty list
75 BBox bbox = new BBox(new LatLon(-180, -90), new LatLon(180, 90));
76 assertTrue(ds.searchPrimitives(bbox).isEmpty(), "Empty data set should produce an empty list.");
77 // data set with elements in the given bbox => these elements
78 Node node = new Node(LatLon.ZERO);
79 Node node2 = new Node(new LatLon(-0.01, -0.01));
80 Way way = TestUtils.newWay("", node, node2);
81 Relation r = new Relation(1);
82 RelationMember rm = new RelationMember("role", node);
83 r.addMember(rm);
84 way.getNodes().forEach(ds::addPrimitive);
85 ds.addPrimitive(way);
86 ds.addPrimitive(r);
87 bbox = new BBox(new LatLon(-1.0, -1.0), new LatLon(1.0, 1.0));
88 List<OsmPrimitive> result = ds.searchPrimitives(bbox);
89 assertEquals(4, result.size(), "We should have found four items.");
90 }
91
92 /**
93 * Unit test of methods {@link DataSet#addChangeSetTag} / {@link DataSet#getChangeSetTags}.
94 */
95 @Test
96 void testChangesetTags() {
97 final DataSet ds = new DataSet();
98 assertTrue(ds.getChangeSetTags().isEmpty());
99 ds.addChangeSetTag("foo", "bar");
100 assertEquals("bar", ds.getChangeSetTags().get("foo"));
101 }
102
103 /**
104 * Unit test of methods {@link DataSet#allNonDeletedPrimitives}
105 * / {@link DataSet#allNonDeletedCompletePrimitives}
106 * / {@link DataSet#allNonDeletedPhysicalPrimitives}.
107 */
108 @Test
109 void testAllNonDeleted() {
110 final DataSet ds = new DataSet();
111 assertTrue(ds.allNonDeletedPrimitives().isEmpty());
112 assertTrue(ds.allNonDeletedCompletePrimitives().isEmpty());
113 assertTrue(ds.allNonDeletedPhysicalPrimitives().isEmpty());
114
115 Node n1 = new Node(1); n1.setCoor(LatLon.NORTH_POLE); n1.setDeleted(true); n1.setIncomplete(false); ds.addPrimitive(n1);
116 Node n2 = new Node(2); n2.setCoor(LatLon.NORTH_POLE); n2.setDeleted(false); n2.setIncomplete(false); ds.addPrimitive(n2);
117 Node n3 = new Node(3); n3.setCoor(LatLon.NORTH_POLE); n3.setDeleted(false); n3.setIncomplete(true); ds.addPrimitive(n3);
118
119 Way w1 = new Way(1); w1.setDeleted(true); w1.setIncomplete(false); ds.addPrimitive(w1);
120 Way w2 = new Way(2); w2.setDeleted(false); w2.setIncomplete(false); ds.addPrimitive(w2);
121 Way w3 = new Way(3); w3.setDeleted(false); w3.setIncomplete(true); ds.addPrimitive(w3);
122
123 Relation r1 = new Relation(1); r1.setDeleted(true); r1.setIncomplete(false); ds.addPrimitive(r1);
124 Relation r2 = new Relation(2); r2.setDeleted(false); r2.setIncomplete(false); ds.addPrimitive(r2);
125 Relation r3 = new Relation(3); r3.setDeleted(false); r3.setIncomplete(true); ds.addPrimitive(r3);
126
127 assertEquals(new HashSet<>(Arrays.asList(n2, n3, w2, w3, r2, r3)),
128 new HashSet<>(ds.allNonDeletedPrimitives()));
129 assertEquals(new HashSet<>(Arrays.asList(n2, w2, r2)),
130 new HashSet<>(ds.allNonDeletedCompletePrimitives()));
131 assertEquals(new HashSet<>(Arrays.asList(n2, w2)),
132 new HashSet<>(ds.allNonDeletedPhysicalPrimitives()));
133 }
134
135 /**
136 * Non-regression test for <a href="https://josm.openstreetmap.de/ticket/14186">Bug #14186</a>.
137 */
138 @Test
139 void testTicket14186() {
140 final DataSet ds = new DataSet();
141 Node n1 = new Node(1);
142 Node n2 = new Node(2);
143 Node n3 = new Node(3);
144 Way w1 = new Way(1);
145 w1.setNodes(Arrays.asList(n1, n2, n3));
146 Way w2 = new Way(2);
147 w2.setNodes(Arrays.asList(n1, n2, n3));
148 ds.addPrimitive(n1);
149 ds.addPrimitive(n2);
150 ds.addPrimitive(n3);
151 ds.addPrimitive(w1);
152 ds.addPrimitive(w2);
153 ds.unlinkNodeFromWays(n2);
154 }
155
156 /**
157 * Non-regression test for <a href="https://josm.openstreetmap.de/ticket/14186">Bug #14186</a>.
158 */
159 @Test
160 void testTicket19438() {
161 final DataSet ds = new DataSet();
162 Node n1 = new Node(1);
163 Node n2 = new Node(2);
164 Node n3 = new Node(3);
165 Node n4 = new Node(4);
166 Way w1 = new Way(1);
167 w1.setNodes(Arrays.asList(n1, n2, n3, n4, n1));
168 w1.setIncomplete(false);
169 assertEquals(5, w1.getNodesCount());
170 assertTrue(w1.isClosed());
171 ds.addPrimitive(n1);
172 ds.addPrimitive(n2);
173 ds.addPrimitive(n3);
174 ds.addPrimitive(n4);
175 ds.addPrimitive(w1);
176 ds.unlinkNodeFromWays(n1);
177 assertTrue(w1.isClosed());
178 assertEquals(4, w1.getNodesCount());
179 }
180
181 /**
182 * Test the selection order.
183 * See <a href="https://josm.openstreetmap.de/ticket/14737">#14737</a>
184 * @since 12069
185 */
186 @Test
187 void testSelectionOrderPreserved() {
188 final DataSet ds = new DataSet();
189 Node n1 = new Node(1);
190 Node n2 = new Node(2);
191 Node n3 = new Node(3);
192 ds.addPrimitive(n1);
193 ds.addPrimitive(n2);
194 ds.addPrimitive(n3);
195
196 assertEquals(Collections.emptyList(), new ArrayList<>(ds.getSelected()));
197
198 ds.setSelected(n1.getPrimitiveId(), n2.getPrimitiveId());
199 assertEquals(Arrays.asList(n1, n2), new ArrayList<>(ds.getSelected()));
200
201 ds.clearSelection();
202 assertEquals(Collections.emptyList(), new ArrayList<>(ds.getSelected()));
203
204 ds.addSelected(n3.getPrimitiveId());
205 ds.addSelected(n1.getPrimitiveId(), n2.getPrimitiveId());
206 assertEquals(Arrays.asList(n3, n1, n2), new ArrayList<>(ds.getSelected()));
207
208 ds.addSelected(n3.getPrimitiveId());
209 assertEquals(Arrays.asList(n3, n1, n2), new ArrayList<>(ds.getSelected()));
210
211 ds.clearSelection(n1.getPrimitiveId());
212 assertEquals(Arrays.asList(n3, n2), new ArrayList<>(ds.getSelected()));
213
214 ds.toggleSelected(n1.getPrimitiveId());
215 assertEquals(Arrays.asList(n3, n2, n1), new ArrayList<>(ds.getSelected()));
216
217 ds.toggleSelected(n2.getPrimitiveId());
218 assertEquals(Arrays.asList(n3, n1), new ArrayList<>(ds.getSelected()));
219 }
220
221 /**
222 * Unit test for {@link DataSet#DataSet(DataSet)}.
223 */
224 @Test
225 void testCopyConstructor() {
226 DataSet ds = new DataSet();
227 assertEqualsDataSet(ds, new DataSet(ds));
228
229 ds.setVersion("fake_version");
230 ds.setUploadPolicy(UploadPolicy.BLOCKED);
231 Node n1 = new Node(LatLon.SOUTH_POLE);
232 Node n2 = new Node(LatLon.NORTH_POLE);
233 Way w = new Way(1);
234 w.setNodes(Arrays.asList(n1, n2));
235 ds.addPrimitive(n1);
236 ds.addPrimitive(n2);
237 ds.addPrimitive(w);
238 Relation r1 = new Relation(1);
239 Relation r2 = new Relation(2);
240 r2.addMember(new RelationMember("role1", n1));
241 r2.addMember(new RelationMember("role2", w));
242 r2.addMember(new RelationMember("role3", r1));
243 ds.addPrimitive(r1);
244 ds.addPrimitive(r2);
245 assertEqualsDataSet(ds, new DataSet(ds));
246 }
247
248 /**
249 * Unit test for {@link DataSet#mergeFrom} - Policies.
250 */
251 @Test
252 void testMergePolicies() {
253 DataSet ds1 = new DataSet();
254 DataSet ds2 = new DataSet();
255
256 ds1.setUploadPolicy(UploadPolicy.BLOCKED);
257 ds2.setUploadPolicy(UploadPolicy.NORMAL);
258 ds1.mergeFrom(ds2);
259 assertEquals(UploadPolicy.BLOCKED, ds1.getUploadPolicy());
260
261 ds1.setUploadPolicy(UploadPolicy.NORMAL);
262 ds2.setUploadPolicy(UploadPolicy.BLOCKED);
263 ds1.mergeFrom(ds2);
264 assertEquals(UploadPolicy.BLOCKED, ds1.getUploadPolicy());
265
266 ds1.setDownloadPolicy(DownloadPolicy.BLOCKED);
267 ds2.setDownloadPolicy(DownloadPolicy.NORMAL);
268 ds1.mergeFrom(ds2);
269 assertEquals(DownloadPolicy.BLOCKED, ds1.getDownloadPolicy());
270
271 ds1.setDownloadPolicy(DownloadPolicy.NORMAL);
272 ds2.setDownloadPolicy(DownloadPolicy.BLOCKED);
273 ds1.mergeFrom(ds2);
274 assertEquals(DownloadPolicy.BLOCKED, ds1.getDownloadPolicy());
275
276 ds2.lock();
277 assertFalse(ds1.isLocked());
278 assertTrue(ds2.isLocked());
279 ds1.mergeFrom(ds2);
280 assertTrue(ds1.isLocked());
281 }
282
283 private static void assertEqualsDataSet(DataSet ds1, DataSet ds2) {
284 assertEquals(new ArrayList<>(ds1.getNodes()), new ArrayList<>(ds2.getNodes()));
285 assertEquals(new ArrayList<>(ds1.getWays()), new ArrayList<>(ds2.getWays()));
286 assertEquals(new ArrayList<>(ds1.getRelations()), new ArrayList<>(ds2.getRelations()));
287 assertEquals(new ArrayList<>(ds1.getDataSources()), new ArrayList<>(ds2.getDataSources()));
288 assertEquals(ds1.getUploadPolicy(), ds2.getUploadPolicy());
289 assertEquals(ds1.getVersion(), ds2.getVersion());
290 }
291
292 /**
293 * Checks that enum values are defined in the correct order.
294 */
295 @Test
296 void testEnumOrder() {
297 assertTrue(DownloadPolicy.BLOCKED.compareTo(DownloadPolicy.NORMAL) > 0);
298 assertTrue(UploadPolicy.BLOCKED.compareTo(UploadPolicy.NORMAL) > 0);
299 assertTrue(UploadPolicy.BLOCKED.compareTo(UploadPolicy.DISCOURAGED) > 0);
300 assertTrue(UploadPolicy.DISCOURAGED.compareTo(UploadPolicy.NORMAL) > 0);
301 }
302
303 /**
304 * Checks that data source listeners get called when a data source is added
305 */
306 @Test
307 void testAddDataSourceListener() {
308 DataSourceListener addListener = event -> assertInstanceOf(DataSourceAddedEvent.class, event);
309
310 DataSet ds = new DataSet();
311 ds.addDataSourceListener(addListener);
312 ds.addDataSource(new DataSource(new Bounds(0, 0, 0.1, 0.1), "fake source"));
313
314 }
315
316 /**
317 * Checks that data source listeners get called when a data source is removed
318 */
319 @Test
320 void testRemoveDataSourceListener() {
321 DataSourceListener removeListener = event -> assertInstanceOf(DataSourceRemovedEvent.class, event);
322
323 DataSet ds = new DataSet();
324 ds.addDataSource(new DataSource(new Bounds(0, 0, 0.1, 0.1), "fake source"));
325 ds.addDataSourceListener(removeListener);
326 new DataSet().mergeFrom(ds);
327 }
328
329 /**
330 * Checks that a read-only dataset can be cloned.
331 */
332 @Test
333 void testCloneReadOnly() {
334 DataSet ds = new DataSet();
335 Node n1 = new Node(LatLon.SOUTH_POLE);
336 Node n2 = new Node(LatLon.NORTH_POLE);
337 ds.addPrimitive(n1);
338 ds.addPrimitive(n2);
339 Way w = new Way();
340 w.setNodes(Arrays.asList(n1, n2));
341 ds.addPrimitive(w);
342 Relation r = new Relation();
343 r.setMembers(Collections.singletonList(new RelationMember(null, w)));
344 ds.addPrimitive(r);
345 ds.lock();
346
347 DataSet copy = new DataSet(ds);
348
349 assertEquals(4, copy.allPrimitives().size());
350 assertTrue(copy.isLocked());
351 }
352}
Note: See TracBrowser for help on using the repository browser.