Index: trunk/data_nodist/coastlines.osm
===================================================================
--- trunk/data_nodist/coastlines.osm (revision 10991)
+++ trunk/data_nodist/coastlines.osm (revision 10991)
@@ -0,0 +1,790 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: trunk/src/org/openstreetmap/josm/data/validation/tests/Coastlines.java
===================================================================
--- trunk/src/org/openstreetmap/josm/data/validation/tests/Coastlines.java (revision 10990)
+++ trunk/src/org/openstreetmap/josm/data/validation/tests/Coastlines.java (revision 10991)
@@ -8,9 +8,10 @@
import java.util.Collection;
import java.util.Collections;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
-
-import org.openstreetmap.josm.Main;
+import java.util.Set;
+
import org.openstreetmap.josm.command.ChangeCommand;
import org.openstreetmap.josm.command.Command;
@@ -21,6 +22,6 @@
import org.openstreetmap.josm.data.validation.Test;
import org.openstreetmap.josm.data.validation.TestError;
-import org.openstreetmap.josm.gui.layer.OsmDataLayer;
import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.tools.Geometry;
/**
@@ -29,4 +30,5 @@
* @author frsantos
* @author Teemu Koskinen
+ * @author Gerd Petermann
*/
public class Coastlines extends Test {
@@ -35,8 +37,7 @@
protected static final int REVERSED_COASTLINE = 902;
protected static final int UNCONNECTED_COASTLINE = 903;
-
- private List coastlines;
-
- private Area downloadedArea;
+ protected static final int WRONG_ORDER_COASTLINE = 904;
+
+ private List coastlineWays;
/**
@@ -49,153 +50,183 @@
@Override
public void startTest(ProgressMonitor monitor) {
-
super.startTest(monitor);
-
- OsmDataLayer layer = Main.getLayerManager().getEditLayer();
-
- if (layer != null) {
- downloadedArea = layer.data.getDataSourceArea();
- }
-
- coastlines = new LinkedList<>();
+ coastlineWays = new LinkedList<>();
}
@Override
public void endTest() {
- for (Way c1 : coastlines) {
- Node head = c1.firstNode();
- Node tail = c1.lastNode();
-
- if (c1.getNodesCount() == 0 || head.equals(tail)) {
- continue;
- }
-
- int headWays = 0;
- int tailWays = 0;
- boolean headReversed = false;
- boolean tailReversed = false;
- boolean headUnordered = false;
- boolean tailUnordered = false;
- Way next = null;
- Way prev = null;
-
- for (Way c2 : coastlines) {
- if (c1 == c2) {
- continue;
- }
-
- if (c2.containsNode(head)) {
- headWays++;
- next = c2;
-
- if (head.equals(c2.firstNode())) {
- headReversed = true;
- } else if (!head.equals(c2.lastNode())) {
- headUnordered = true;
- }
- }
-
- if (c2.containsNode(tail)) {
- tailWays++;
- prev = c2;
-
- if (tail.equals(c2.lastNode())) {
- tailReversed = true;
- } else if (!tail.equals(c2.firstNode())) {
- tailUnordered = true;
- }
- }
- }
-
- // To avoid false positives on upload (only modified primitives
- // are visited), we have to check possible connection to ways
- // that are not in the set of validated primitives.
- if (headWays == 0) {
- Collection refs = head.getReferrers();
- for (OsmPrimitive ref : refs) {
- if (ref != c1 && isCoastline(ref)) {
- // ref cannot be in coastlines, otherwise we would
- // have picked it up already
- headWays++;
- next = (Way) ref;
-
- if (head.equals(next.firstNode())) {
- headReversed = true;
- } else if (!head.equals(next.lastNode())) {
- headUnordered = true;
+ checkConnections();
+ checkDirection();
+ coastlineWays = null;
+ super.endTest();
+ }
+
+ /**
+ * Check connections between coastline ways.
+ * The nodes of a coastline way have to fullfil these rules:
+ * 1) the first node must be connected to the last node of a coastline way (which might be the same way)
+ * 2) the last node must be connected to the first node of a coastline way (which might be the same way)
+ * 3) all other nodes must not be connected to a coastline way
+ * 4) the number of referencing coastline ways must be 1 or 2
+ * Nodes outside the download area are special cases, we may not know enough about the connected ways.
+ */
+ private void checkConnections() {
+ Area downloadedArea = null;
+ for (Way w : coastlineWays) {
+ if (downloadedArea == null) {
+ downloadedArea = w.getDataSet().getDataSourceArea();
+ }
+ int numNodes = w.getNodesCount();
+ for (int i = 0; i < numNodes; i++) {
+ Node n = w.getNode(i);
+ List refs = n.getReferrers();
+ Set connectedWays = new HashSet<>();
+ for (OsmPrimitive p : refs) {
+ if (p != w && isCoastline(p)) {
+ connectedWays.add((Way) p);
+ }
+ }
+ if (i == 0) {
+ if (connectedWays.isEmpty() && n != w.lastNode() && n.getCoor().isIn(downloadedArea)) {
+ addError(UNCONNECTED_COASTLINE, w, null, n);
+ }
+ if (connectedWays.size() == 1 && n != connectedWays.iterator().next().lastNode()) {
+ checkIfReversed(w, connectedWays.iterator().next(), n);
+ }
+ if (connectedWays.size() == 1 && w.isClosed() && connectedWays.iterator().next().isClosed()) {
+ addError(UNORDERED_COASTLINE, w, connectedWays, n);
+ }
+ } else if (i == numNodes - 1) {
+ if (connectedWays.isEmpty() && n != w.firstNode() && n.getCoor().isIn(downloadedArea)) {
+ addError(UNCONNECTED_COASTLINE, w, null, n);
+ }
+ if (connectedWays.size() == 1 && n != connectedWays.iterator().next().firstNode()) {
+ checkIfReversed(w, connectedWays.iterator().next(), n);
+ }
+ } else if (!connectedWays.isEmpty()) {
+ addError(UNORDERED_COASTLINE, w, connectedWays, n);
+ }
+ }
+ }
+ }
+
+ /**
+ * Check if two or more coastline ways form a closed clockwise way
+ */
+ private void checkDirection() {
+ HashSet done = new HashSet<>();
+ for (Way w : coastlineWays) {
+ if (done.contains(w))
+ continue;
+ List visited = new ArrayList<>();
+ done.add(w);
+ visited.add(w);
+ List nodes = new ArrayList<>(w.getNodes());
+ Way curr = w;
+ while (nodes.get(0) != nodes.get(nodes.size()-1)) {
+ boolean foundContinuation = false;
+ for (OsmPrimitive p : curr.lastNode().getReferrers()) {
+ if (p != curr && isCoastline(p)) {
+ Way other = (Way) p;
+ if (done.contains(other))
+ continue;
+ if (other.firstNode() == curr.lastNode()) {
+ foundContinuation = true;
+ curr = other;
+ done.add(curr);
+ visited.add(curr);
+ nodes.remove(nodes.size()-1); // remove duplicate connection node
+ nodes.addAll(curr.getNodes());
+ break;
}
}
}
- }
- if (tailWays == 0) {
- Collection refs = tail.getReferrers();
- for (OsmPrimitive ref : refs) {
- if (ref != c1 && isCoastline(ref)) {
- tailWays++;
- prev = (Way) ref;
-
- if (tail.equals(prev.lastNode())) {
- tailReversed = true;
- } else if (!tail.equals(prev.firstNode())) {
- tailUnordered = true;
- }
- }
- }
- }
-
- List primitives = new ArrayList<>();
- primitives.add(c1);
-
- if (headWays == 0 || tailWays == 0) {
- List highlight = new ArrayList<>();
-
- if (headWays == 0 && head.getCoor().isIn(downloadedArea)) {
- highlight.add(head);
- }
- if (tailWays == 0 && tail.getCoor().isIn(downloadedArea)) {
- highlight.add(tail);
- }
-
- if (!highlight.isEmpty()) {
- errors.add(new TestError(this, Severity.ERROR, tr("Unconnected coastline"),
- UNCONNECTED_COASTLINE, primitives, highlight));
- }
- }
-
- boolean unordered = false;
- boolean reversed = headWays == 1 && headReversed && tailWays == 1 && tailReversed;
-
- if (headWays > 1 || tailWays > 1) {
- unordered = true;
- } else if (headUnordered || tailUnordered) {
- unordered = true;
- } else if (reversed && next == prev) {
- unordered = true;
- } else if ((headReversed || tailReversed) && headReversed != tailReversed) {
- unordered = true;
- }
-
- if (unordered) {
- List highlight = new ArrayList<>();
-
- if (headWays > 1 || headUnordered || headReversed || reversed) {
- highlight.add(head);
- }
- if (tailWays > 1 || tailUnordered || tailReversed || reversed) {
- highlight.add(tail);
- }
-
- errors.add(new TestError(this, Severity.ERROR, tr("Unordered coastline"),
- UNORDERED_COASTLINE, primitives, highlight));
- } else if (reversed) {
- errors.add(new TestError(this, Severity.ERROR, tr("Reversed coastline"),
- REVERSED_COASTLINE, primitives));
- }
- }
-
- coastlines = null;
- downloadedArea = null;
-
- super.endTest();
+ if (!foundContinuation)
+ break;
+ }
+ // simple closed ways are reported by WronglyOrderedWays
+ if (visited.size() > 1 && nodes.get(0) == nodes.get(nodes.size()-1) && Geometry.isClockwise(nodes)) {
+ errors.add(new TestError(this, Severity.WARNING, tr("Reversed coastline: land not on left side"),
+ WRONG_ORDER_COASTLINE, visited));
+ }
+ }
+ }
+
+ /**
+ * Check if a reversed way would fit, if yes, add fixable "reversed" error, "unordered" else
+ * @param w way that might be reversed
+ * @param other other way that is connected to w
+ * @param n1 node at which w and other are connected
+ */
+ private void checkIfReversed(Way w, Way other, Node n1) {
+ boolean headFixedWithReverse = false;
+ boolean tailFixedWithReverse = false;
+ int otherCoastlineWays = 0;
+ Way connectedToFirst = null;
+ for (int i = 0; i < 2; i++) {
+ Node n = (i == 0) ? w.firstNode() : w.lastNode();
+ List refs = n.getReferrers();
+ for (OsmPrimitive p : refs) {
+ if (p != w && isCoastline(p)) {
+ Way cw = (Way) p;
+ if (i == 0 && cw.firstNode() == n) {
+ headFixedWithReverse = true;
+ connectedToFirst = cw;
+ } else if (i == 1 && cw.lastNode() == n) {
+ if (cw != connectedToFirst)
+ tailFixedWithReverse = true;
+ } else
+ otherCoastlineWays++;
+ }
+ }
+ }
+ if (otherCoastlineWays == 0 && headFixedWithReverse && tailFixedWithReverse)
+ addError(REVERSED_COASTLINE, w, null, null);
+ else
+ addError(UNORDERED_COASTLINE, w, Collections.singletonList(other), n1);
+ }
+
+ /**
+ * Add error if not already done
+ * @param errCode the error code
+ * @param w the way that is in error
+ * @param otherWays collection of other ways in error or null
+ * @param n the node to be highlighted or null
+ */
+ private void addError(int errCode, Way w, Collection otherWays, Node n) {
+ String msg;
+ switch (errCode) {
+ case UNCONNECTED_COASTLINE:
+ msg = tr("Unconnected coastline");
+ break;
+ case UNORDERED_COASTLINE:
+ msg = tr("Unordered coastline");
+ break;
+ case REVERSED_COASTLINE:
+ msg = tr("Reversed coastline");
+ break;
+ default:
+ msg = tr("invalid coastline"); // should not happen
+ }
+ Set primitives = new HashSet<>();
+ primitives.add(w);
+ if (otherWays != null)
+ primitives.addAll(otherWays);
+ // check for repeated error
+ for (TestError e : errors) {
+ if (e.getCode() != errCode)
+ continue;
+ if (errCode != REVERSED_COASTLINE && !e.getHighlighted().contains(n))
+ continue;
+ if (e.getPrimitives().size() != primitives.size())
+ continue;
+ if (!e.getPrimitives().containsAll(primitives))
+ continue;
+ return; // we already know this error
+ }
+ if (errCode != REVERSED_COASTLINE)
+ errors.add(new TestError(this, Severity.ERROR, msg, errCode, primitives, Collections.singletonList(n)));
+ else
+ errors.add(new TestError(this, Severity.ERROR, msg, errCode, primitives));
}
@@ -206,5 +237,5 @@
if (isCoastline(way)) {
- coastlines.add(way);
+ coastlineWays.add(way);
}
}
Index: trunk/src/org/openstreetmap/josm/gui/DefaultNameFormatter.java
===================================================================
--- trunk/src/org/openstreetmap/josm/gui/DefaultNameFormatter.java (revision 10990)
+++ trunk/src/org/openstreetmap/josm/gui/DefaultNameFormatter.java (revision 10991)
@@ -136,4 +136,22 @@
}
+ /**
+ * Formats a name for an {@link OsmPrimitive}.
+ *
+ * @param osm the primitive
+ * @return the name
+ * @since 10991
+ */
+ public String format(OsmPrimitive osm) {
+ if (osm instanceof Node) {
+ return format((Node) osm);
+ } else if (osm instanceof Way) {
+ return format((Way) osm);
+ } else if (osm instanceof Relation) {
+ return format((Relation) osm);
+ }
+ return null;
+ }
+
@Override
public String format(Node node) {
Index: trunk/test/unit/org/openstreetmap/josm/data/validation/tests/CoastlinesTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/validation/tests/CoastlinesTest.java (revision 10991)
+++ trunk/test/unit/org/openstreetmap/josm/data/validation/tests/CoastlinesTest.java (revision 10991)
@@ -0,0 +1,38 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import java.util.stream.Collectors;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * JUnit Test of coastline validation test.
+ */
+public class CoastlinesTest {
+
+ private static final Coastlines COASTLINES = new Coastlines();
+ private static final WronglyOrderedWays WRONGLY_ORDERED_WAYS = new WronglyOrderedWays();
+
+ /**
+ * Setup test.
+ */
+ @Rule
+ @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+ public JOSMTestRules test = new JOSMTestRules().commands();
+
+ /**
+ * Test all error cases manually created in coastline.osm.
+ * @throws Exception in case of error
+ */
+ @Test
+ public void testCoastlineFile() throws Exception {
+ ValidatorTestUtils.testSampleFile("data_nodist/coastlines.osm",
+ ds -> ds.getWays().stream().filter(
+ w -> "coastline".equals(w.get("natural"))).collect(Collectors.toList()),
+ null, COASTLINES, WRONGLY_ORDERED_WAYS);
+ }
+}
Index: trunk/test/unit/org/openstreetmap/josm/data/validation/tests/MultipolygonTestTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/validation/tests/MultipolygonTestTest.java (revision 10990)
+++ trunk/test/unit/org/openstreetmap/josm/data/validation/tests/MultipolygonTestTest.java (revision 10991)
@@ -5,13 +5,8 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import java.io.FileInputStream;
-import java.io.InputStream;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.stream.Collectors;
import org.junit.Rule;
@@ -22,8 +17,5 @@
import org.openstreetmap.josm.data.osm.Relation;
import org.openstreetmap.josm.data.osm.Way;
-import org.openstreetmap.josm.data.validation.TestError;
-import org.openstreetmap.josm.gui.DefaultNameFormatter;
import org.openstreetmap.josm.gui.mappaint.ElemStyles;
-import org.openstreetmap.josm.io.OsmReader;
import org.openstreetmap.josm.testutils.JOSMTestRules;
@@ -90,37 +82,7 @@
@Test
public void testMultipolygonFile() throws Exception {
- try (InputStream is = new FileInputStream("data_nodist/multipolygon.osm")) {
- for (Relation r : OsmReader.parseDataSet(is, null).getRelations()) {
- if (r.isMultipolygon()) {
- String name = DefaultNameFormatter.getInstance().format(r);
- String codes = r.get("josm_error_codes");
- if (codes != null) {
- List errors = new ArrayList<>();
- for (org.openstreetmap.josm.data.validation.Test test : Arrays.asList(MULTIPOLYGON_TEST, RELATION_TEST)) {
- test.initialize();
- test.startTest(null);
- test.visit(r);
- test.endTest();
- errors.addAll(test.getErrors());
- }
- Set expectedCodes = new TreeSet<>();
- for (String code : codes.split(",")) {
- expectedCodes.add(Integer.parseInt(code));
- }
- Set actualCodes = new TreeSet<>();
- for (TestError error : errors) {
- Integer code = error.getCode();
- assertTrue(name + " does not expect JOSM error code " + code + ": " + error.getDescription(),
- expectedCodes.contains(code));
- actualCodes.add(code);
- }
- assertEquals(name + " " + expectedCodes + " => " + actualCodes,
- expectedCodes.size(), actualCodes.size());
- } else if (r.hasKey("name") && (r.getName().startsWith("06") || r.getName().startsWith("07"))) {
- fail(name + " lacks josm_error_codes tag");
- }
- }
- }
- }
+ ValidatorTestUtils.testSampleFile("data_nodist/multipolygon.osm",
+ ds -> ds.getRelations().stream().filter(Relation::isMultipolygon).collect(Collectors.toList()),
+ name -> name.startsWith("06") || name.startsWith("07"), MULTIPOLYGON_TEST, RELATION_TEST);
}
}
Index: trunk/test/unit/org/openstreetmap/josm/data/validation/tests/ValidatorTestUtils.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/validation/tests/ValidatorTestUtils.java (revision 10991)
+++ trunk/test/unit/org/openstreetmap/josm/data/validation/tests/ValidatorTestUtils.java (revision 10991)
@@ -0,0 +1,71 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.validation.tests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.validation.Test;
+import org.openstreetmap.josm.data.validation.TestError;
+import org.openstreetmap.josm.gui.DefaultNameFormatter;
+import org.openstreetmap.josm.io.OsmReader;
+
+/**
+ * Utilities for validator unit tests.
+ */
+public final class ValidatorTestUtils {
+
+ private ValidatorTestUtils() {
+ // Hide default constructor for utilities classes
+ }
+
+ static void testSampleFile(String sampleFile,
+ Function> provider, Predicate namePredicate,
+ Test ... tests) throws Exception {
+ try (InputStream is = new FileInputStream(sampleFile)) {
+ for (T t: provider.apply(OsmReader.parseDataSet(is, null))) {
+ String name = DefaultNameFormatter.getInstance().format(t);
+ String codes = t.get("josm_error_codes");
+ if (codes != null) {
+ List errors = new ArrayList<>();
+ for (Test test : tests) {
+ test.initialize();
+ test.startTest(null);
+ test.visit(Collections.singleton(t));
+ test.endTest();
+ errors.addAll(test.getErrors());
+ }
+ Set expectedCodes = new TreeSet<>();
+ if (!"none".equals(codes)) {
+ for (String code : codes.split(",")) {
+ expectedCodes.add(Integer.parseInt(code));
+ }
+ }
+ Set actualCodes = new TreeSet<>();
+ for (TestError error : errors) {
+ Integer code = error.getCode();
+ assertTrue(name + " does not expect JOSM error code " + code + ": " + error.getDescription(),
+ expectedCodes.contains(code));
+ actualCodes.add(code);
+ }
+ assertEquals(name + " " + expectedCodes + " => " + actualCodes,
+ expectedCodes.size(), actualCodes.size());
+ } else if (t.hasKey("name") && namePredicate != null && namePredicate.test(t.getName())) {
+ fail(name + " lacks josm_error_codes tag");
+ }
+ }
+ }
+ }
+}