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

Last change on this file since 1925 was 1925, checked in by jttt, 15 years ago

Replaced Relation.members with Relation.getMembers()

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