Index: test/org/openstreetmap/josm/data/osm/DataSetTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/DataSetTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/DataSetTest.java (revision 146) @@ -0,0 +1,116 @@ +package org.openstreetmap.josm.data.osm; + +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedList; + +import org.openstreetmap.josm.data.SelectionChangedListener; +import org.openstreetmap.josm.testframework.MotherObject; + +public class DataSetTest extends MotherObject { + + private final class TestSelectionChangeListener implements SelectionChangedListener { + public Collection called; + public void selectionChanged(Collection newSelection) { + called = newSelection; + } + } + + private DataSet ds; + private Node node1; + private Node node2; + private Node node3; + private Segment segment; + private Way way; + + @Override protected void setUp() throws Exception { + super.setUp(); + ds = createDataSet(); + Iterator it = ds.nodes.iterator(); + node1 = it.next(); + node2 = it.next(); + node3 = it.next(); + segment = ds.segments.iterator().next(); + way = ds.ways.iterator().next(); + } + + public void testAllPrimitives() { + Collection all = ds.allPrimitives(); + assertContainsSame(all, node1, node2, node3, segment, way); + } + + public void testAllNonDeletedPrimitives() { + assertEquals(5, ds.allNonDeletedPrimitives().size()); + node1.deleted = true; + assertEquals(4, ds.allNonDeletedPrimitives().size()); + } + + public void testClearSelection() { + node1.selected = true; + ds.clearSelection(); + assertFalse(node1.selected); + } + + public void testGetSelected() { + node1.selected = true; + segment.selected = true; + Collection sel = ds.getSelected(); + assertContainsSame(sel, node1, segment); + } + + public void testSetSelected() { + Collection sel = new LinkedList(); + sel.add(node1); + sel.add(way); + ds.setSelected(sel); + assertTrue(node1.selected); + assertFalse(node2.selected); + assertTrue(way.selected); + } + + public void testSetSelectedOsmPrimitive() { + ds.setSelected(node3); + assertTrue(node3.selected); + assertFalse(node2.selected); + } + + public void testFireSelectionChanged() { + TestSelectionChangeListener l = new TestSelectionChangeListener(); + ds.addSelectionChangedListener(l); + ds.setSelected(segment); + assertNotNull(l.called); + assertEquals(1, l.called.size()); + assertSame(segment, l.called.iterator().next()); + } + + public void testAddRemoveSelectionChangedListener() { + TestSelectionChangeListener l = new TestSelectionChangeListener(); + ds.addSelectionChangedListener(l); + ds.removeSelectionChangedListener(l); + ds.setSelected(way); + assertNull(l.called); + } + + public void testAddAllSelectionListener() { + DataSet ds2 = new DataSet(); + TestSelectionChangeListener l1 = new TestSelectionChangeListener(); + TestSelectionChangeListener l2 = new TestSelectionChangeListener(); + ds2.addSelectionChangedListener(l1); + ds2.addSelectionChangedListener(l2); + ds.addAllSelectionListener(ds2); + ds2.removeSelectionChangedListener(l1); + ds.setSelected(node2); + assertNotNull(l1.called); + assertNotNull(l2.called); + } + + public void testRealEqual() { + Collection all = new LinkedList(); + all.add(new Node(node1)); + all.add(new Node(node2)); + all.add(new Node(node3)); + all.add(createSegment(segment.id, node1, node2)); + all.add(createWay(way.id, way.segments.iterator().next())); + assertTrue(ds.realEqual(all)); + } +} Index: test/org/openstreetmap/josm/data/osm/NodeTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/NodeTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/NodeTest.java (revision 146) @@ -0,0 +1,48 @@ +package org.openstreetmap.josm.data.osm; + +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.testframework.MotherObject; + +public class NodeTest extends MotherObject { + + private Node node; + + @Override protected void setUp() throws Exception { + super.setUp(); + node = createNode(); + } + + public void testVisit() { + OsmPrimitiveTest.TestCalledVisitor v = new OsmPrimitiveTest.TestCalledVisitor(); + node.visit(v); + assertEquals("Node", v.called); + } + + public void testCloneFromRealEqual() { + Node node2 = createNode(23,3,4); + assertFalse(node2.realEqual(node)); + assertFalse(node.realEqual(node2)); + node.cloneFrom(node2); + assertTrue(node2.realEqual(node)); + assertTrue(node.realEqual(node2)); + } + + public void testNodeNode() { + Node node2 = new Node(node); + assertTrue(node2.realEqual(node)); + } + + public void testNodeLatLon() { + LatLon latLon = new LatLon(1,2); + node = new Node(latLon); + assertEquals(node.coor, latLon); + } + + public void testCompareToNodeTypeBiggestOrComparedAfterId() { + assertEquals(1, node.compareTo(createSegment())); + assertEquals(1, node.compareTo(createWay())); + Node node2 = createNode(23,1,2); + assertEquals(-1, node.compareTo(node2)); + assertEquals(1, node2.compareTo(node)); + } +} Index: test/org/openstreetmap/josm/data/osm/OsmPrimitiveTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/OsmPrimitiveTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/OsmPrimitiveTest.java (revision 146) @@ -0,0 +1,94 @@ +package org.openstreetmap.josm.data.osm; + +import java.util.Date; + +import org.openstreetmap.josm.data.osm.visitor.Visitor; +import org.openstreetmap.josm.testframework.MotherObject; + +public class OsmPrimitiveTest extends MotherObject { + + public final static class TestCalledVisitor implements Visitor { + public String called; + + public void visit(Node n) { + assertNull(called); + called = "Node"; + } + + public void visit(Segment s) { + assertNull(called); + called = "Segment"; + } + + public void visit(Way w) { + assertNull(called); + called = "Way"; + } + } + + private OsmPrimitive osm; + private boolean visited; + + @Override protected void setUp() throws Exception { + super.setUp(); + osm = new OsmPrimitive() { + @Override public void visit(Visitor visitor) { + visited = true; + } + + public int compareTo(OsmPrimitive o) { + return 0; + } + }; + visited = false; + } + + public void testHashCodeReturnsIdIfNotZeroAndNotZeroIfIdIsZero() { + osm.id = 23; + assertEquals(23, osm.hashCode()); + osm.id = 0; + assertTrue(0 != osm.hashCode()); + } + + public void testVisit() { + osm.visit(new Visitor(){ + public void visit(Node n) {} + public void visit(Segment s) {} + public void visit(Way w) {}}); + assertTrue(visited); + } + + public void testEqualsIsEqualOnlyIfIdAndClassMatchesAndIdIsNotZero() { + Node node = createNode(1,23,42); + Node node2 = createNode(1); + assertTrue(node.equals(node2)); + Segment segment = createSegment(1); + assertFalse(node.equals(segment)); + node2.id = 2; + assertFalse(node.equals(node2)); + node2.id = 0; + node.id = 0; + assertFalse(node.equals(node2)); + } + + public void testKeysPutRemoveGet() { + assertTrue(osm.keySet().isEmpty()); + osm.put("foo", "bar"); + assertEquals(1, osm.keySet().size()); + assertEquals("bar", osm.get("foo")); + assertEquals(1, osm.entrySet().size()); + assertEquals("foo", osm.entrySet().iterator().next().getKey()); + assertEquals("bar", osm.entrySet().iterator().next().getValue()); + + osm.remove("asd"); + assertEquals(1, osm.keySet().size()); + osm.remove("foo"); + assertEquals(0, osm.keySet().size()); + } + + public void testGetTimeStr() { + assertNull(osm.getTimeStr()); + osm.timestamp = new Date(1); + assertEquals("1970-01-01 01:00:00", osm.getTimeStr()); + } +} Index: test/org/openstreetmap/josm/data/osm/SegmentTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/SegmentTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/SegmentTest.java (revision 146) @@ -0,0 +1,66 @@ +package org.openstreetmap.josm.data.osm; + +import org.openstreetmap.josm.testframework.MotherObject; + +public class SegmentTest extends MotherObject { + + private Segment segment; + + @Override protected void setUp() throws Exception { + super.setUp(); + segment = createSegment(); + } + + public void testVisit() { + OsmPrimitiveTest.TestCalledVisitor v = new OsmPrimitiveTest.TestCalledVisitor(); + segment.visit(v); + assertEquals("Segment", v.called); + } + + public void testCloneFromRealEqual() { + Segment s2 = createSegment(23, createNode(1,2,3), createNode(2,3,4)); + segment.cloneFrom(s2); + assertTrue(segment.realEqual(s2)); + assertTrue(s2.realEqual(segment)); + assertSame(segment.from, s2.from); + assertSame(segment.to, s2.to); + } + + public void testSegmentSegment() { + Segment s = new Segment(segment); + assertTrue(s.realEqual(segment)); + } + + public void testSegmentNodeNode() { + Segment s = new Segment(createNode(1,2,3), createNode(4,5,6)); + assertEquals(2.0, s.from.coor.lat()); + assertEquals(6.0, s.to.coor.lon()); + } + + public void testSegmentLong() { + Segment s = new Segment(23); + assertEquals(23, s.id); + } + + public void testEqualPlace() { + Segment s = createSegment(); + assertFalse(s.equalPlace(segment)); + assertFalse(segment.equalPlace(s)); + s.from.coor = segment.to.coor; + s.to.coor = segment.from.coor; + assertTrue(s.equalPlace(segment)); + assertTrue(segment.equalPlace(s)); + } + + public void testCompareToSegmentSmallerThanNodeBiggerThanWayOrCompareAfterId() { + Segment s = createSegment(23); + assertEquals(-1, s.compareTo(createNode())); + assertEquals(1, s.compareTo(createWay())); + + assertEquals(1, s.compareTo(segment)); + assertEquals(-1, segment.compareTo(s)); + segment.id = s.id; + assertEquals(0, segment.compareTo(s)); + assertEquals(0, s.compareTo(segment)); + } +} Index: test/org/openstreetmap/josm/data/osm/WayTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/WayTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/WayTest.java (revision 146) @@ -0,0 +1,53 @@ +package org.openstreetmap.josm.data.osm; + +import org.openstreetmap.josm.testframework.MotherObject; + +public class WayTest extends MotherObject { + + private Way way; + + @Override protected void setUp() throws Exception { + super.setUp(); + way = createWay(); + } + + public void testVisit() { + OsmPrimitiveTest.TestCalledVisitor v = new OsmPrimitiveTest.TestCalledVisitor(); + way.visit(v); + assertEquals("Way", v.called); + } + + public void testCloneFromRealEqual() { + Way w2 = createWay(42); + way.cloneFrom(w2); + assertTrue(way.realEqual(w2)); + assertEquals(w2.segments.size(), way.segments.size()); + } + + public void testWayWay() { + Way w = new Way(way); + assertEquals(way.id, w.id); + assertTrue(way.realEqual(w)); + } + + public void testWay() { + Way w = new Way(); + assertEquals(0, w.id); + assertEquals(0, w.segments.size()); + } + + public void testCompareToWaySmallestOrCompareAfterId() { + Way w = createWay(23); + assertEquals(-1, w.compareTo(createNode())); + assertEquals(-1, w.compareTo(createSegment())); + + assertEquals(1, w.compareTo(way)); + assertEquals(-1, way.compareTo(w)); + } + + public void testIsIncomplete() { + way.segments.add(new Segment(23)); + assertTrue(way.isIncomplete()); + } + +} Index: test/org/openstreetmap/josm/data/osm/visitor/AddVisitorTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/visitor/AddVisitorTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/visitor/AddVisitorTest.java (revision 146) @@ -0,0 +1,42 @@ +package org.openstreetmap.josm.data.osm.visitor; + +import java.lang.reflect.Field; + +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.testframework.MotherObject; + +public class AddVisitorTest extends MotherObject { + + private AddVisitor v; + private DataSet ds; + + @Override protected void setUp() throws Exception { + super.setUp(); + ds = new DataSet(); + v = new AddVisitor(ds); + } + + public void testAddVisitorDataSet() throws Exception { + AddVisitor v = new AddVisitor(ds); + Field vDs = AddVisitor.class.getDeclaredField("ds"); + vDs.setAccessible(true); + assertSame(ds, vDs.get(v)); + } + + public void testVisitNode() { + createNode(23).visit(v); + assertEquals(1, ds.nodes.size()); + assertEquals(23, ds.nodes.iterator().next().id); + } + + public void testVisitSegment() { + createSegment().visit(v); + assertEquals(1, ds.segments.size()); + } + + public void testVisitWay() { + createWay().visit(v); + assertEquals(1, ds.ways.size()); + } + +} Index: test/org/openstreetmap/josm/data/osm/visitor/AllNodesVisitorTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/visitor/AllNodesVisitorTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/visitor/AllNodesVisitorTest.java (revision 146) @@ -0,0 +1,58 @@ +package org.openstreetmap.josm.data.osm.visitor; + +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedList; + +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.osm.Segment; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.testframework.MotherObject; + +public class AllNodesVisitorTest extends MotherObject { + + private AllNodesVisitor v; + + @Override protected void setUp() throws Exception { + super.setUp(); + v = new AllNodesVisitor(); + } + + public void testVisitNode() { + Node node = createNode(); + node.visit(v); + assertEquals(1, v.nodes.size()); + assertSame(node, v.nodes.iterator().next()); + } + + public void testVisitSegment() { + Segment s = createSegment(); + s.visit(v); + assertEquals(2, v.nodes.size()); + Iterator it = v.nodes.iterator(); + assertSame(s.from, it.next()); + assertSame(s.to, it.next()); + } + + public void testVisitWay() { + Way w = createWay(createSegment()); + w.visit(v); + int numberOfNodes = 2*w.segments.size(); + assertEquals(numberOfNodes, v.nodes.size()); + Iterator itNodes = v.nodes.iterator(); + Iterator it = w.segments.iterator(); + for (int i = 0; i < numberOfNodes; ++i) + assertSame(i%2==0?it.next().from:it.next().to, itNodes.next()); + } + + public void testGetAllNodes() { + Collection all = new LinkedList(); + all.add(createNode()); + all.add(createSegment()); + Collection nodes = AllNodesVisitor.getAllNodes(all); + + assertEquals(3, nodes.size()); + } + +} Index: test/org/openstreetmap/josm/data/osm/visitor/BoundingXYVisitorTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/visitor/BoundingXYVisitorTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/visitor/BoundingXYVisitorTest.java (revision 146) @@ -0,0 +1,61 @@ +package org.openstreetmap.josm.data.osm.visitor; + +import org.openstreetmap.josm.data.Bounds; +import org.openstreetmap.josm.data.coor.EastNorth; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.testframework.MotherObject; + +public class BoundingXYVisitorTest extends MotherObject { + + private BoundingXYVisitor v; + + private void assertVisitorFilled() { + assertNotNull(v.max); + assertNotNull(v.min); + } + + @Override protected void setUp() throws Exception { + super.setUp(); + v = new BoundingXYVisitor(); + } + + public void testVisitNode() { + Node node = createNode(); + node.visit(v); + assertVisitorFilled(); + assertEquals(node.eastNorth.east(), v.min.east()); + assertEquals(node.eastNorth.north(), v.min.north()); + assertEquals(v.max, v.min); + } + + public void testVisitSegment() { + createSegment().visit(v); + assertVisitorFilled(); + assertFalse(v.max.equals(v.min)); + } + + public void testVisitWay() { + createWay(createSegment()).visit(v); + assertVisitorFilled(); + assertFalse(v.max.equals(v.min)); + } + + public void testVisitEastNorth() { + v.visit(new EastNorth(123,321)); + v.visit(new EastNorth(124,322)); + assertEquals(123.0, v.min.east()); + assertEquals(124.0, v.max.east()); + assertEquals(321.0, v.min.north()); + assertEquals(322.0, v.max.north()); + } + + public void testGetBounds() { + Node node = createNode(); + v.visit(node); + Bounds b = v.getBounds(); + assertNotNull(b); + assertEquals(node.coor.lat(), b.min.lat()); + assertEquals(node.coor.lon(), b.min.lon()); + } + +} Index: test/org/openstreetmap/josm/data/osm/visitor/CollectBackReferencesVisitorTest.java =================================================================== --- test/org/openstreetmap/josm/data/osm/visitor/CollectBackReferencesVisitorTest.java (revision 146) +++ test/org/openstreetmap/josm/data/osm/visitor/CollectBackReferencesVisitorTest.java (revision 146) @@ -0,0 +1,42 @@ +package org.openstreetmap.josm.data.osm.visitor; + +import java.lang.reflect.Field; + +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.testframework.MotherObject; + +public class CollectBackReferencesVisitorTest extends MotherObject { + + private CollectBackReferencesVisitor v; + private DataSet ds; + + @Override protected void setUp() throws Exception { + super.setUp(); + ds = createDataSet(); + v = new CollectBackReferencesVisitor(ds); + } + + public void testCollectBackReferencesVisitor() throws Exception { + DataSet dataSet = new DataSet(); + CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(dataSet); + Field f = v.getClass().getDeclaredField("ds"); + f.setAccessible(true); + assertSame(dataSet, f.get(v)); + } + + public void testVisitNode() { + ds.nodes.iterator().next().visit(v); + assertContainsSame(v.data, ds.segments.iterator().next(), ds.ways.iterator().next()); + } + + public void testVisitSegment() { + ds.segments.iterator().next().visit(v); + assertContainsSame(v.data, ds.ways.iterator().next()); + } + + public void testVisitWay() { + ds.ways.iterator().next().visit(v); + assertEquals(0, v.data.size()); + } + +} Index: test/org/openstreetmap/josm/testframework/DateParserTest.java =================================================================== --- test/org/openstreetmap/josm/testframework/DateParserTest.java (revision 143) +++ (revision ) @@ -1,31 +1,0 @@ -package org.openstreetmap.josm.testframework; - -import java.text.ParseException; -import java.text.SimpleDateFormat; -import java.util.Date; - -import junit.framework.TestCase; - -import org.openstreetmap.josm.tools.DateParser; - -public class DateParserTest extends TestCase { - - public void testWrong() throws Exception { - try { - DateParser.parse("imi"); - assertTrue(false); - } catch (ParseException pe) { - } - } - - public void testRight() throws Exception { - Date d = new SimpleDateFormat("dd MM yyyy HH mm ss SSS Z").parse("23 11 2001 23 05 42 123 +0100"); - Date d2 = new Date(d.getTime()-123); - assertEquals(d2, DateParser.parse("11/23/2001 23:05:42")); - assertEquals(d2, DateParser.parse("11/23/2001T23:05:42")); - assertEquals(d2, DateParser.parse("11/23/2001T23:05:42+001")); - assertEquals(d2, DateParser.parse("2001-11-23T23:05:42+01:00")); - assertEquals(d, DateParser.parse("11/23/2001T23:05:42.123")); - assertEquals(d, DateParser.parse("11/23/2001T23:05:42.123+001")); - } -} Index: test/org/openstreetmap/josm/testframework/MotherObject.java =================================================================== --- test/org/openstreetmap/josm/testframework/MotherObject.java (revision 146) +++ test/org/openstreetmap/josm/testframework/MotherObject.java (revision 146) @@ -0,0 +1,92 @@ +package org.openstreetmap.josm.testframework; + +import java.util.Arrays; +import java.util.Collection; +import java.util.LinkedList; + +import junit.framework.TestCase; + +import org.openstreetmap.josm.Main; +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.osm.DataSet; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.OsmPrimitive; +import org.openstreetmap.josm.data.osm.Segment; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.projection.Epsg4326; + +public class MotherObject extends TestCase { + + @Override protected void setUp() throws Exception { + super.setUp(); + Main.proj = new Epsg4326(); + } + + public Node createNode(int id) { + return createNode(id, 0, 0); + } + + public Node createNode(int id, double lat, double lon) { + Node n = createNode(lat, lon); + n.id = id; + return n; + } + + public Node createNode() { + return createNode(Math.random()*360-180, Math.random()*180-90); + } + + public Node createNode(double lat, double lon) { + return new Node(new LatLon(lat,lon)); + } + + + public Segment createSegment(long id) { + Segment s = createSegment(); + s.id = id; + return s; + } + public Segment createSegment(long id, Node from, Node to) { + Segment s = new Segment(from, to); + s.id = id; + return s; + } + public Segment createSegment() { + return new Segment(createNode(), createNode()); + } + + + public Way createWay() { + return createWay(0); + } + public Way createWay(Segment... segments) { + return createWay(0, segments); + } + public Way createWay(long id, Segment... segments) { + Way way = new Way(); + way.segments.addAll(Arrays.asList(segments)); + way.id = id; + return way; + } + + public DataSet createDataSet() { + DataSet ds = new DataSet(); + Node node1 = createNode(); + Node node2 = createNode(); + Node node3 = createNode(); + Segment segment = createSegment(23, node1, node2); + Way way = createWay(42, segment); + ds.nodes.add(node1); + ds.nodes.add(node2); + ds.nodes.add(node3); + ds.segments.add(segment); + ds.ways.add(way); + return ds; + } + + public void assertContainsSame(Collection data, OsmPrimitive... all) { + Collection copy = new LinkedList(data); + copy.removeAll(Arrays.asList(all)); + assertEquals(0, copy.size()); + } +} Index: test/org/openstreetmap/josm/tools/DateParserTest.java =================================================================== --- test/org/openstreetmap/josm/tools/DateParserTest.java (revision 146) +++ test/org/openstreetmap/josm/tools/DateParserTest.java (revision 146) @@ -0,0 +1,31 @@ +package org.openstreetmap.josm.tools; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +import junit.framework.TestCase; + +import org.openstreetmap.josm.tools.DateParser; + +public class DateParserTest extends TestCase { + + public void testWrong() throws Exception { + try { + DateParser.parse("imi"); + assertTrue(false); + } catch (ParseException pe) { + } + } + + public void testRight() throws Exception { + Date d = new SimpleDateFormat("dd MM yyyy HH mm ss SSS Z").parse("23 11 2001 23 05 42 123 +0100"); + Date d2 = new Date(d.getTime()-123); + assertEquals(d2, DateParser.parse("11/23/2001 23:05:42")); + assertEquals(d2, DateParser.parse("11/23/2001T23:05:42")); + assertEquals(d2, DateParser.parse("11/23/2001T23:05:42+001")); + assertEquals(d2, DateParser.parse("2001-11-23T23:05:42+01:00")); + assertEquals(d, DateParser.parse("11/23/2001T23:05:42.123")); + assertEquals(d, DateParser.parse("11/23/2001T23:05:42.123+001")); + } +}