Changeset 7275 in josm
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/org/openstreetmap/josm/data/validation/tests/MapCSSTagChecker.java
r7248 r7275 18 18 import java.util.List; 19 19 import java.util.Map; 20 import java.util.Set; 20 21 import java.util.regex.Matcher; 21 22 import java.util.regex.Pattern; … … 49 50 import org.openstreetmap.josm.io.UTFInputStreamReader; 50 51 import org.openstreetmap.josm.tools.CheckParameterUtil; 52 import org.openstreetmap.josm.tools.MultiMap; 51 53 import org.openstreetmap.josm.tools.Predicate; 52 54 import org.openstreetmap.josm.tools.Utils; … … 58 60 public class MapCSSTagChecker extends Test.TagTest { 59 61 62 /** 63 * A grouped MapCSSRule with multiple selectors for a single declaration. 64 * @see MapCSSRule 65 */ 60 66 public static class GroupedMapCSSRule { 67 /** MapCSS selectors **/ 61 68 final public List<Selector> selectors; 69 /** MapCSS declaration **/ 62 70 final public Declaration declaration; 63 71 72 /** 73 * Constructs a new {@code GroupedMapCSSRule}. 74 * @param selectors MapCSS selectors 75 * @param declaration MapCSS declaration 76 */ 64 77 public GroupedMapCSSRule(List<Selector> selectors, Declaration declaration) { 65 78 this.selectors = selectors; … … 112 125 } 113 126 114 final List<TagCheck> checks = newArrayList<>();127 final MultiMap<String, TagCheck> checks = new MultiMap<>(); 115 128 116 129 static class TagCheck implements Predicate<OsmPrimitive> { … … 204 217 check.change.add(toTag); 205 218 } else if ("fixRemove".equals(ai.key)) { 206 CheckParameterUtil.ensureThat(!(ai.val instanceof String) || !val.contains("="), "Unexpected '='. Please only specify the key to remove!"); 219 CheckParameterUtil.ensureThat(!(ai.val instanceof String) || !(val != null && val.contains("=")), 220 "Unexpected '='. Please only specify the key to remove!"); 207 221 final PrimitiveToTag toTag = PrimitiveToTag.ofMapCSSObject(ai.val, true); 208 222 check.change.add(toTag); … … 323 337 324 338 /** 325 * Replaces occurrences of {@code{i.key}}, {@code{i.value}}, {@code{i.tag}}in {@code s} by the corresponding339 * Replaces occurrences of <code>{i.key}</code>, <code>{i.value}</code>, <code>{i.tag}</code> in {@code s} by the corresponding 326 340 * key/value/tag of the {@code index}-th {@link Condition} of {@code matchingSelector}. 327 341 */ … … 484 498 /** 485 499 * Obtains all {@link TestError}s for the {@link OsmPrimitive} {@code p}. 500 * @param p The OSM primitive 501 * @param includeOtherSeverity if {@code true}, errors of severity {@link Severity#OTHER} (info) will also be returned 502 * @return all errors for the given primitive, with or without those of "info" severity 486 503 */ 487 504 public Collection<TestError> getErrorsForPrimitive(OsmPrimitive p, boolean includeOtherSeverity) { 488 505 final ArrayList<TestError> r = new ArrayList<>(); 489 506 final Environment env = new Environment(p, new MultiCascade(), Environment.DEFAULT_LAYER, null); 490 for (TagCheck check : checks) { 491 if (Severity.OTHER.equals(check.getSeverity()) && !includeOtherSeverity) { 492 continue; 493 } 494 final Selector selector = check.whichSelectorMatchesEnvironment(env); 495 if (selector != null) { 496 check.rule.declaration.execute(env); 497 final TestError error = check.getErrorForPrimitive(p, selector, env); 498 if (error != null) { 499 error.setTester(new MapCSSTagCheckerAndRule(check.rule)); 500 r.add(error); 507 for (Set<TagCheck> schecks : checks.values()) { 508 for (TagCheck check : schecks) { 509 if (Severity.OTHER.equals(check.getSeverity()) && !includeOtherSeverity) { 510 continue; 511 } 512 final Selector selector = check.whichSelectorMatchesEnvironment(env); 513 if (selector != null) { 514 check.rule.declaration.execute(env); 515 final TestError error = check.getErrorForPrimitive(p, selector, env); 516 if (error != null) { 517 error.setTester(new MapCSSTagCheckerAndRule(check.rule)); 518 r.add(error); 519 } 501 520 } 502 521 } … … 516 535 517 536 /** 518 * Adds a new MapCSS config file from the given {@code Reader}.519 * @param css The reader537 * Adds a new MapCSS config file from the given URL. 538 * @param url The unique URL of the MapCSS config file 520 539 * @throws ParseException if the config file does not match MapCSS syntax 540 * @throws IOException if any I/O error occurs 541 * @since 521 542 */ 522 public void addMapCSS(Reader css) throws ParseException { 523 checks.addAll(TagCheck.readMapCSS(css)); 543 public void addMapCSS(String url) throws ParseException, IOException { 544 CheckParameterUtil.ensureParameterNotNull(url, "url"); 545 try (InputStream s = new CachedFile(url).getInputStream()) { 546 checks.putAll(url, TagCheck.readMapCSS(new BufferedReader(UTFInputStreamReader.create(s)))); 547 } 524 548 } 525 549 … … 534 558 Main.info(tr("Adding {0} to tag checker", i)); 535 559 } 536 try (InputStream s = new CachedFile(i).getInputStream()) { 537 addMapCSS(new BufferedReader(UTFInputStreamReader.create(s))); 538 } 560 addMapCSS(i); 539 561 } catch (IOException ex) { 540 562 Main.warn(tr("Failed to add {0} to tag checker", i)); -
trunk/src/org/openstreetmap/josm/tools/MultiMap.java
r7005 r7275 12 12 13 13 /** 14 * MultiMap - maps keys to multiple values 14 * MultiMap - maps keys to multiple values. 15 15 * 16 16 * Corresponds to Google guava LinkedHashMultimap and Apache Collections MultiValueMap 17 17 * but it is an independent (simple) implementation. 18 18 * 19 * @param <A> Key type 20 * @param <B> Value type 21 * 22 * @since 2702 19 23 */ 20 24 public class MultiMap<A, B> { … … 30 34 31 35 /** 32 * Constructs a new {@code MultiMap} with the specified initial capacity. 36 * Constructs a new {@code MultiMap} with the specified initial capacity. 33 37 * @param capacity the initial capacity 34 38 */ … … 41 45 * 42 46 * Can be called multiple times with the same key, but different value. 47 * @param key key with which the specified value is to be associated 48 * @param value value to be associated with the specified key 43 49 */ 44 50 public void put(A key, B value) { … … 56 62 * Afterwards containsKey(key) will return true and get(key) will return 57 63 * an empty Set instead of null. 64 * @param key key with which an empty set is to be associated 58 65 */ 59 66 public void putVoid(A key) { … … 67 74 * 68 75 * Adds to the mappings that are already there. 76 * @param key key with which the specified values are to be associated 77 * @param values values to be associated with the specified key 69 78 */ 70 79 public void putAll(A key, Collection<B> values) { … … 79 88 /** 80 89 * Get the keySet. 90 * @return a set view of the keys contained in this map 91 * @see Map#keySet() 81 92 */ 82 93 public Set<A> keySet() { … … 90 101 * Modifications of the returned list changes the underling map, 91 102 * but you should better not do that. 103 * @param key the key whose associated value is to be returned 104 * @return the set of values to which the specified key is mapped, or {@code null} if this map contains no mapping for the key 105 * @see Map#get(Object) 92 106 */ 93 107 public Set<B> get(A key) { … … 97 111 /** 98 112 * Like get, but returns an empty Set if nothing has been mapped to the key. 113 * @param key the key whose associated value is to be returned 114 * @return the set of values to which the specified key is mapped, or an empty set if this map contains no mapping for the key 99 115 */ 100 116 public Set<B> getValues(A key) { … … 104 120 } 105 121 122 /** 123 * Returns {@code true} if this map contains no key-value mappings. 124 * @return {@code true} if this map contains no key-value mappings 125 * @see Map#isEmpty() 126 */ 106 127 public boolean isEmpty() { 107 128 return map.isEmpty(); 108 129 } 109 130 131 /** 132 * Returns {@code true} if this map contains a mapping for the specified key. 133 * @param key key whose presence in this map is to be tested 134 * @return {@code true} if this map contains a mapping for the specified key 135 * @see Map#containsKey(Object) 136 */ 110 137 public boolean containsKey(A key) { 111 138 return map.containsKey(key); … … 124 151 } 125 152 153 /** 154 * Removes all of the mappings from this map. The map will be empty after this call returns. 155 * @see Map#clear() 156 */ 126 157 public void clear() { 127 158 map.clear(); 128 159 } 129 160 161 /** 162 * Returns a Set view of the mappings contained in this map. 163 * The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. 164 * @return a set view of the mappings contained in this map 165 * @see Map#entrySet() 166 */ 130 167 public Set<Entry<A, Set<B>>> entrySet() { 131 168 return map.entrySet(); … … 134 171 /** 135 172 * Returns the number of keys. 173 * @return the number of key-value mappings in this map 174 * @see Map#size() 136 175 */ 137 176 public int size() { … … 141 180 /** 142 181 * Returns a collection of all value sets. 182 * @return a collection view of the values contained in this map 183 * @see Map#values() 143 184 */ 144 185 public Collection<Set<B>> values() { … … 147 188 148 189 /** 149 * Removes a cerain key=value mapping. 150 * 151 * @return true, if something was removed 190 * Removes a certain key=value mapping. 191 * @param key key whose mapping is to be removed from the map 192 * @param value value whose mapping is to be removed from the map 193 * 194 * @return {@code true}, if something was removed 152 195 */ 153 196 public boolean remove(A key, B value) { … … 161 204 /** 162 205 * Removes all mappings for a certain key. 206 * @param key key whose mapping is to be removed from the map 207 * @return the previous value associated with key, or {@code null} if there was no mapping for key. 208 * @see Map#remove(Object) 163 209 */ 164 210 public Set<B> remove(A key) { -
trunk/test/unit/org/openstreetmap/josm/data/validation/tests/MapCSSTagCheckerTest.java
r7081 r7275 12 12 import java.util.List; 13 13 import java.util.Map; 14 import java.util.Set; 14 15 15 16 import org.junit.BeforeClass; … … 23 24 import org.openstreetmap.josm.data.validation.Severity; 24 25 import org.openstreetmap.josm.data.validation.TestError; 26 import org.openstreetmap.josm.data.validation.tests.MapCSSTagChecker.TagCheck; 25 27 import org.openstreetmap.josm.tools.Predicate; 26 28 import org.openstreetmap.josm.tools.Utils; … … 74 76 75 77 LinkedHashSet<String> assertionErrors = new LinkedHashSet<>(); 76 for (final MapCSSTagChecker.TagCheck check : c.checks) { 77 System.out.println("Check: "+check); 78 for (final Map.Entry<String, Boolean> i : check.assertions.entrySet()) { 79 System.out.println("- Assertion: "+i); 80 final OsmPrimitive p = TestUtils.createPrimitive(i.getKey()); 81 final boolean isError = Utils.exists(c.getErrorsForPrimitive(p, true), new Predicate<TestError>() { 82 @Override 83 public boolean evaluate(TestError e) { 84 //noinspection EqualsBetweenInconvertibleTypes 85 return e.getTester().equals(check.rule); 78 for (final Set<TagCheck> schecks : c.checks.values()) { 79 for (final TagCheck check : schecks) { 80 System.out.println("Check: "+check); 81 for (final Map.Entry<String, Boolean> i : check.assertions.entrySet()) { 82 System.out.println("- Assertion: "+i); 83 final OsmPrimitive p = TestUtils.createPrimitive(i.getKey()); 84 final boolean isError = Utils.exists(c.getErrorsForPrimitive(p, true), new Predicate<TestError>() { 85 @Override 86 public boolean evaluate(TestError e) { 87 //noinspection EqualsBetweenInconvertibleTypes 88 return e.getTester().equals(check.rule); 89 } 90 }); 91 if (isError != i.getValue()) { 92 final String error = MessageFormat.format("Expecting test ''{0}'' (i.e., {1}) to {2} {3} (i.e., {4})", 93 check.getMessage(p), check.rule.selectors, i.getValue() ? "match" : "not match", i.getKey(), p.getKeys()); 94 System.err.println(error); 95 assertionErrors.add(error); 86 96 } 87 });88 if (isError != i.getValue()) {89 final String error = MessageFormat.format("Expecting test ''{0}'' (i.e., {1}) to {2} {3} (i.e., {4})",90 check.getMessage(p), check.rule.selectors, i.getValue() ? "match" : "not match", i.getKey(), p.getKeys());91 System.err.println(error);92 assertionErrors.add(error);93 97 } 94 98 }
Note:
See TracChangeset
for help on using the changeset viewer.
