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

Last change on this file was 18853, checked in by taylor.smock, 7 months ago

See #16567: Update to JUnit 5

This removes new JOSMTestRules() with no additional setup and most
JOSMFixture calls.

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