source: josm/trunk/test/functional/org/openstreetmap/josm/io/OsmServerBackreferenceReaderTest.java@ 7088

Last change on this file since 7088 was 7082, checked in by Don-vip, 10 years ago

see #8465 - replace Utils.UTF_8 by StandardCharsets.UTF_8, new in Java 7
File size: 17.9 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.io;
3
4import static org.junit.Assert.assertEquals;
5import static org.junit.Assert.assertNotNull;
6import static org.junit.Assert.fail;
7
8import java.io.File;
9import java.io.FileInputStream;
10import java.io.FileOutputStream;
11import java.io.IOException;
12import java.io.OutputStreamWriter;
13import java.io.PrintWriter;
14import java.nio.charset.StandardCharsets;
15import java.text.MessageFormat;
16import java.util.ArrayList;
17import java.util.HashSet;
18import java.util.Set;
19import java.util.logging.Logger;
20
21import org.junit.Before;
22import org.junit.BeforeClass;
23import org.junit.Test;
24import org.openstreetmap.josm.JOSMFixture;
25import org.openstreetmap.josm.Main;
26import org.openstreetmap.josm.data.coor.LatLon;
27import org.openstreetmap.josm.data.osm.Changeset;
28import org.openstreetmap.josm.data.osm.DataSet;
29import org.openstreetmap.josm.data.osm.Node;
30import org.openstreetmap.josm.data.osm.OsmPrimitive;
31import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
32import org.openstreetmap.josm.data.osm.Relation;
33import org.openstreetmap.josm.data.osm.RelationMember;
34import org.openstreetmap.josm.data.osm.Way;
35import org.openstreetmap.josm.data.projection.Projections;
36import org.openstreetmap.josm.gui.io.UploadStrategy;
37import org.openstreetmap.josm.gui.io.UploadStrategySpecification;
38import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
39
40/**
41 * Reads primitives referring to a particular primitive (ways including a node, relations referring to a relation)
42 * @since 1806
43 */
44public class OsmServerBackreferenceReaderTest {
45 static private final Logger logger = Logger.getLogger(OsmServerBackreferenceReader.class.getName());
46
47 protected static Node lookupNode(DataSet ds, int i) {
48 for (Node n : ds.getNodes()) {
49 if (("node-" + i).equals(n.get("name"))) return n;
50 }
51 fail("Cannot find node "+i);
52 return null;
53 }
54
55 protected static Way lookupWay(DataSet ds, int i) {
56 for (Way w : ds.getWays()) {
57 if (("way-" + i).equals(w.get("name"))) return w;
58 }
59 fail("Cannot find way "+i);
60 return null;
61 }
62
63 protected static Relation lookupRelation(DataSet ds, int i) {
64 for (Relation r : ds.getRelations()) {
65 if (("relation-" + i).equals(r.get("name"))) return r;
66 }
67 fail("Cannot find relation "+i);
68 return null;
69 }
70
71 protected static void populateTestDataSetWithNodes(DataSet ds) {
72 for (int i=0;i<100;i++) {
73 Node n = new Node();
74 n.setCoor(new LatLon(-36.6,47.6));
75 n.put("name", "node-"+i);
76 ds.addPrimitive(n);
77 }
78 }
79
80 protected static void populateTestDataSetWithWays(DataSet ds) {
81 for (int i=0;i<20;i++) {
82 Way w = new Way();
83 for (int j = 0; j < 10;j++) {
84 w.addNode(lookupNode(ds, i+j));
85 }
86 w.put("name", "way-"+i);
87 ds.addPrimitive(w);
88 }
89 }
90
91 protected static void populateTestDataSetWithRelations(DataSet ds) {
92 for (int i=0;i<10;i++) {
93 Relation r = new Relation();
94 r.put("name", "relation-" +i);
95 for (int j =0; j < 10; j++) {
96 RelationMember member = new RelationMember("node-" + j, lookupNode(ds, i + j));
97 r.addMember(member);
98 }
99 for (int j =0; j < 5; j++) {
100 RelationMember member = new RelationMember("way-" + j, lookupWay(ds, i + j));
101 r.addMember(member);
102 }
103 if (i > 5) {
104 for (int j =0; j < 3; j++) {
105 RelationMember member = new RelationMember("relation-" + j, lookupRelation(ds, j));
106 logger.info(MessageFormat.format("adding relation {0} to relation {1}", j, i));
107 r.addMember(member);
108 }
109 }
110 ds.addPrimitive(r);
111 }
112 }
113
114 protected static DataSet buildTestDataSet() {
115 DataSet ds = new DataSet();
116 ds.setVersion("0.6");
117
118 populateTestDataSetWithNodes(ds);
119 populateTestDataSetWithWays(ds);
120 populateTestDataSetWithRelations(ds);
121 return ds;
122 }
123
124 /**
125 * creates the dataset on the server.
126 *
127 * @param ds the data set
128 * @throws OsmTransferException
129 */
130 static public void createDataSetOnServer(DataSet ds) throws OsmTransferException {
131 logger.info("creating data set on the server ...");
132 ArrayList<OsmPrimitive> primitives = new ArrayList<>();
133 primitives.addAll(ds.getNodes());
134 primitives.addAll(ds.getWays());
135 primitives.addAll(ds.getRelations());
136 OsmServerWriter writer = new OsmServerWriter();
137 Changeset cs = new Changeset();
138 writer.uploadOsm(new UploadStrategySpecification().setStrategy(UploadStrategy.SINGLE_REQUEST_STRATEGY), primitives, cs, NullProgressMonitor.INSTANCE);
139 OsmApi.getOsmApi().closeChangeset(cs, NullProgressMonitor.INSTANCE);
140 }
141
142 static DataSet testDataSet;
143
144 @BeforeClass
145 public static void init() throws OsmTransferException {
146 logger.info("initializing ...");
147
148 JOSMFixture.createFunctionalTestFixture().init();
149
150 // don't use atomic upload, the test API server can't cope with large diff uploads
151 //
152 Main.pref.put("osm-server.atomic-upload", false);
153 Main.setProjection(Projections.getProjectionByCode("EPSG:3857")); // Mercator
154 Main.logLevel = 4;
155
156 File dataSetCacheOutputFile = new File(System.getProperty("java.io.tmpdir"), MultiFetchServerObjectReaderTest.class.getName() + ".dataset");
157
158 String p = System.getProperty("useCachedDataset");
159 if (p != null && Boolean.parseBoolean(p.trim().toLowerCase())) {
160 logger.info(MessageFormat.format("property ''{0}'' set, using cached dataset", "useCachedDataset"));
161 return;
162 }
163
164 logger.info(MessageFormat.format("property ''{0}'' not set to true, creating test dataset on the server. property is ''{1}''", "useCachedDataset", p));
165
166 // build and upload the test data set
167 //
168 logger.info("creating test data set ....");
169 testDataSet = buildTestDataSet();
170 logger.info("uploading test data set ...");
171 createDataSetOnServer(testDataSet);
172
173 try (
174 PrintWriter pw = new PrintWriter(
175 new OutputStreamWriter(new FileOutputStream(dataSetCacheOutputFile), StandardCharsets.UTF_8)
176 )) {
177 logger.info(MessageFormat.format("caching test data set in ''{0}'' ...", dataSetCacheOutputFile.toString()));
178 try (OsmWriter w = new OsmWriter(pw, false, testDataSet.getVersion())) {
179 w.header();
180 w.writeDataSources(testDataSet);
181 w.writeContent(testDataSet);
182 w.footer();
183 }
184 } catch(IOException e) {
185 fail(MessageFormat.format("failed to open file ''{0}'' for writing", dataSetCacheOutputFile.toString()));
186 }
187 }
188
189 private DataSet ds;
190
191 /**
192 * Setup test.
193 */
194 @Before
195 public void setUp() throws IOException, IllegalDataException {
196 File f = new File(System.getProperty("java.io.tmpdir"), MultiFetchServerObjectReaderTest.class.getName() + ".dataset");
197 logger.info(MessageFormat.format("reading cached dataset ''{0}''", f.toString()));
198 ds = new DataSet();
199 try (FileInputStream fis = new FileInputStream(f)) {
200 ds = OsmReader.parseDataSet(fis, NullProgressMonitor.INSTANCE);
201 }
202 }
203
204 @Test
205 public void testBackrefrenceForNode() throws OsmTransferException {
206 Node n = lookupNode(ds, 0);
207 assertNotNull(n);
208 Way w = lookupWay(ds, 0);
209 assertNotNull(w);
210
211 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(n);
212 reader.setReadFull(false);
213 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
214 assertEquals(10, referers.getNodes().size());
215 assertEquals(1, referers.getWays().size());
216 assertEquals(0, referers.getRelations().size());
217 for (Way way : referers.getWays()) {
218 assertEquals(w.getId(), way.getId());
219 assertEquals(false, way.isIncomplete());
220 }
221 }
222
223 @Test
224 public void testBackrefrenceForNode_Full() throws OsmTransferException {
225 Node n = lookupNode(ds, 0);
226 assertNotNull(n);
227 Way w = lookupWay(ds, 0);
228 assertNotNull(w);
229
230 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(n);
231 reader.setReadFull(true);
232 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
233 assertEquals(10, referers.getNodes().size());
234 assertEquals(1, referers.getWays().size());
235 assertEquals(0, referers.getRelations().size());
236 for (Way way : referers.getWays()) {
237 assertEquals(w.getId(), way.getId());
238 assertEquals(false, way.isIncomplete());
239 assertEquals(10, w.getNodesCount());
240 }
241 }
242
243 @Test
244 public void testBackrefrenceForWay() throws OsmTransferException {
245 Way w = lookupWay(ds, 1);
246 assertNotNull(w);
247 // way with name "way-1" is referred to by two relations
248 //
249
250 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(w);
251 reader.setReadFull(false);
252 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
253 assertEquals(0, referers.getNodes().size()); // no nodes loaded
254 assertEquals(6, referers.getWays().size()); // 6 ways referred by two relations
255 for (Way w1 : referers.getWays()) {
256 assertEquals(true, w1.isIncomplete());
257 }
258 assertEquals(2, referers.getRelations().size()); // two relations referring to w
259
260 Relation r = lookupRelation(referers, 0);
261 assertNotNull(r);
262 assertEquals(false, r.isIncomplete());
263 r = lookupRelation(referers, 1);
264 assertEquals(false, r.isIncomplete());
265 }
266
267 @Test
268 public void testBackrefrenceForWay_Full() throws OsmTransferException {
269 Way w = lookupWay(ds, 1);
270 assertNotNull(w);
271 // way with name "way-1" is referred to by two relations
272 //
273
274 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(w);
275 reader.setReadFull(true);
276 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
277 assertEquals(6, referers.getWays().size()); // 6 ways referred by two relations
278 for (Way w1 : referers.getWays()) {
279 assertEquals(false, w1.isIncomplete());
280 }
281 assertEquals(2, referers.getRelations().size()); // two relations referring to
282 Set<Long> expectedNodeIds = new HashSet<>();
283 for (Way way : referers.getWays()) {
284 Way orig = (Way) ds.getPrimitiveById(way);
285 for (Node n : orig.getNodes()) {
286 expectedNodeIds.add(n.getId());
287 }
288 }
289 assertEquals(expectedNodeIds.size(), referers.getNodes().size());
290 for (Node n : referers.getNodes()) {
291 assertEquals(true, expectedNodeIds.contains(n.getId()));
292 }
293
294 Relation r = lookupRelation(referers, 0);
295 assertNotNull(r);
296 assertEquals(false, r.isIncomplete());
297 r = lookupRelation(referers, 1);
298 assertEquals(false, r.isIncomplete());
299 }
300
301 @Test
302 public void testBackrefrenceForRelation() throws OsmTransferException {
303 Relation r = lookupRelation(ds, 1);
304 assertNotNull(r);
305 // way with name "relation-1" is referred to by four relations:
306 // relation-6, relation-7, relation-8, relation-9
307 //
308
309 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(r);
310 reader.setReadFull(false);
311 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
312
313 Set<Long> referringRelationsIds = new HashSet<>();
314 r = lookupRelation(referers, 6);
315 assertNotNull(r);
316 assertEquals(false, r.isIncomplete());
317 referringRelationsIds.add(r.getId());
318 r = lookupRelation(referers, 7);
319 assertNotNull(r);
320 assertEquals(false, r.isIncomplete());
321 referringRelationsIds.add(r.getId());
322 r = lookupRelation(referers, 8);
323 assertNotNull(r);
324 assertEquals(false, r.isIncomplete());
325 referringRelationsIds.add(r.getId());
326 r = lookupRelation(referers, 9);
327 assertNotNull(r);
328 assertEquals(false, r.isIncomplete());
329 referringRelationsIds.add(r.getId());
330
331 for (Relation r1 : referers.getRelations()) {
332 if (!referringRelationsIds.contains(r1.getId())) {
333 assertEquals(true, r1.isIncomplete());
334 }
335 }
336
337 // make sure we read all ways referred to by parent relations. These
338 // ways are incomplete after reading.
339 //
340 Set<Long> expectedWayIds = new HashSet<>();
341 for (RelationMember m : lookupRelation(ds, 6).getMembers()) {
342 if (m.isWay()) {
343 expectedWayIds.add(m.getMember().getId());
344 }
345 }
346 for (RelationMember m : lookupRelation(ds, 7).getMembers()) {
347 if (m.isWay()) {
348 expectedWayIds.add(m.getMember().getId());
349 }
350 }
351 for (RelationMember m : lookupRelation(ds, 8).getMembers()) {
352 if (m.isWay()) {
353 expectedWayIds.add(m.getMember().getId());
354 }
355 }
356 for (RelationMember m : lookupRelation(ds, 9).getMembers()) {
357 if (m.isWay()) {
358 expectedWayIds.add(m.getMember().getId());
359 }
360 }
361
362 assertEquals(expectedWayIds.size(), referers.getWays().size());
363 for (Way w1 : referers.getWays()) {
364 assertEquals(true, expectedWayIds.contains(w1.getId()));
365 assertEquals(true, w1.isIncomplete());
366 }
367
368 // make sure we didn't read any nodes
369 //
370 assertEquals(0, referers.getNodes().size());
371 }
372
373 protected Set<Long> getNodeIdsInWay(Way way) {
374 HashSet<Long> ret = new HashSet<>();
375 if (way == null)return ret;
376 for (Node n: way.getNodes()) {
377 ret.add(n.getId());
378 }
379 return ret;
380 }
381
382 protected Set<Long> getNodeIdsInRelation(Relation r) {
383 HashSet<Long> ret = new HashSet<>();
384 if (r == null) return ret;
385 for (RelationMember m: r.getMembers()) {
386 if (m.isNode()) {
387 ret.add(m.getMember().getId());
388 } else if (m.isWay()) {
389 ret.addAll(getNodeIdsInWay(m.getWay()));
390 } else if (m.isRelation()) {
391 ret.addAll(getNodeIdsInRelation(m.getRelation()));
392 }
393 }
394 return ret;
395 }
396
397 @Test
398 public void testBackrefrenceForRelation_Full() throws OsmTransferException {
399 Relation r = lookupRelation(ds, 1);
400 assertNotNull(r);
401 // way with name "relation-1" is referred to by four relations:
402 // relation-6, relation-7, relation-8, relation-9
403 //
404
405 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(r);
406 reader.setReadFull(true);
407 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
408
409 Set<Long> referringRelationsIds = new HashSet<>();
410 r = lookupRelation(referers, 6);
411 assertNotNull(r);
412 assertEquals(false, r.isIncomplete());
413 referringRelationsIds.add(r.getId());
414 r = lookupRelation(referers, 7);
415 assertNotNull(r);
416 assertEquals(false, r.isIncomplete());
417 referringRelationsIds.add(r.getId());
418 r = lookupRelation(referers, 8);
419 assertNotNull(r);
420 assertEquals(false, r.isIncomplete());
421 referringRelationsIds.add(r.getId());
422 r = lookupRelation(referers, 9);
423 assertNotNull(r);
424 assertEquals(false, r.isIncomplete());
425 referringRelationsIds.add(r.getId());
426
427 // all relations are fully loaded
428 //
429 for (Relation r1 : referers.getRelations()) {
430 assertEquals(false, r1.isIncomplete());
431 }
432
433 // make sure we read all ways referred to by parent relations. These
434 // ways are completely read after reading the relations
435 //
436 Set<Long> expectedWayIds = new HashSet<>();
437 for (RelationMember m : lookupRelation(ds, 6).getMembers()) {
438 if (m.isWay()) {
439 expectedWayIds.add(m.getMember().getId());
440 }
441 }
442 for (RelationMember m : lookupRelation(ds, 7).getMembers()) {
443 if (m.isWay()) {
444 expectedWayIds.add(m.getMember().getId());
445 }
446 }
447 for (RelationMember m : lookupRelation(ds, 8).getMembers()) {
448 if (m.isWay()) {
449 expectedWayIds.add(m.getMember().getId());
450 }
451 }
452 for (RelationMember m : lookupRelation(ds, 9).getMembers()) {
453 if (m.isWay()) {
454 expectedWayIds.add(m.getMember().getId());
455 }
456 }
457 for (long id : expectedWayIds) {
458 Way w = (Way) referers.getPrimitiveById(id, OsmPrimitiveType.WAY);
459 assertNotNull(w);
460 assertEquals(false, w.isIncomplete());
461 }
462
463 Set<Long> expectedNodeIds = new HashSet<>();
464 for (int i = 6; i < 10; i++) {
465 Relation r1 = lookupRelation(ds, i);
466 expectedNodeIds.addAll(getNodeIdsInRelation(r1));
467 }
468
469 assertEquals(expectedNodeIds.size(), referers.getNodes().size());
470 for (Node n : referers.getNodes()) {
471 assertEquals(true, expectedNodeIds.contains(n.getId()));
472 }
473 }
474}
Note: See TracBrowser for help on using the repository browser.