/*
* Copyright (C) 2008 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 29-Nov-2008
*/
package uk.me.parabola.mkgmap.osmstyle;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import uk.me.parabola.imgfmt.app.Coord;
import uk.me.parabola.mkgmap.general.LevelInfo;
import uk.me.parabola.mkgmap.reader.osm.Element;
import uk.me.parabola.mkgmap.reader.osm.FeatureKind;
import uk.me.parabola.mkgmap.reader.osm.GType;
import uk.me.parabola.mkgmap.reader.osm.Rule;
import uk.me.parabola.mkgmap.reader.osm.TypeResult;
import uk.me.parabola.mkgmap.reader.osm.Way;
import uk.me.parabola.mkgmap.scan.SyntaxException;
import func.lib.StringStyleFileLoader;
import org.junit.Test;
import static func.lib.TestUtils.makeRuleSet;
import static org.junit.Assert.*;
public class RuleFileReaderTest
{
/**
* Test of a file containing a number of different rules, with varying
* formatting and including comments.
*/
@Test
public void testLoad
() {
RuleSet rs = makeRuleSet
("highway=footway & type=rough [0x2 level 2]\n" +
"highway=footway | highway = path\n" +
" [0x3]\n# comment here\n" +
"foo=\nbar & bar=two [0x4]\n" +
"highway=* & oneway=true [0x6 level 1]\n" +
"");
Element el =
new Way
(1);
el.
addTag("highway",
"footway");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("plain footway",
"[0x3 level 0]", type.
toString());
el.
addTag("type",
"rough");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("rough footway",
"[0x2 level 2]", type.
toString());
}
/**
* Test for non-standard level specification. You can give a range
* of levels, rather than defaulting the max end to 0.
*/
@Test
public void testLevel
() {
RuleSet rs = makeRuleSet
(
"highway=primary [0x1 level 1-3]"
);
Element el =
new Way
(1);
el.
addTag("highway",
"primary");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("min level",
1, type.
getMinLevel());
assertEquals
("max level",
3, type.
getMaxLevel());
}
/**
* Try out arithmetic comparisons and mixtures of 'and' and 'or'.
*/
@Test
public void testComplexExpressions
() {
String str =
"a=b & (c=d | e=f) & x>10 [0x1]\n";
RuleSet rs = makeRuleSet
(str
);
Element el =
new Way
(1);
el.
addTag("a",
"b");
el.
addTag("c",
"d");
el.
addTag("x",
"11");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("expression ok",
1, type.
getType());
// fails with x less than 10
el.
addTag("x",
"9");
type = getFirstType
(rs, el
);
assertNull
("x too low", type
);
// also fails with x equal to 10
el.
addTag("x",
"10");
type = getFirstType
(rs, el
);
assertNull
("x too low", type
);
// OK with x > 10
el.
addTag("x",
"100");
el.
addTag("e",
"f");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("c and e set",
1, type.
getType());
el.
addTag("c",
"");
el.
addTag("e",
"");
type = getFirstType
(rs, el
);
assertNull
("none of c and e set", type
);
el.
addTag("e",
"f");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("e is set to f",
1, type.
getType());
}
/**
* Test based on email on the mailing list at:
* http://www.mkgmap.org.uk/pipermail/mkgmap-dev/2009q3/003009.html
* See that email for an explanation.
*/
@Test
public void testComparasons
() {
String str =
"highway=null_null & layer<0 [0x01 resolution 10]\n" +
"highway=null_null & layer=0 [0x02 resolution 10]\n" +
"highway=null_null & layer>0 [0x03 resolution 10]\n" +
"highway=null_null & layer='-1' [0x04 resolution 10]\n" +
"highway=null_null & layer='0' [0x05 resolution 10]\n" +
"highway=null_null & layer='1' [0x06 resolution 10]\n" +
"highway=null_null & layer='+1' [0x07 resolution 10]\n" +
"highway=null_null [0x08 resolution 10]";
RuleSet rs = makeRuleSet
(str
);
// 9902
Element el =
new Way
(1);
el.
addTag("highway",
"null_null");
el.
addTag("layer",
"-1");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("9902 layer = -1", 0x1, type.
getType());
// 9912
el.
addTag("layer",
"0");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("9912 layer = 0", 0x2, type.
getType());
// 9922
el.
deleteTag("layer");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("9922 no layer tag", 0x8, type.
getType());
// 9932
el.
addTag("layer",
"1");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("9932 layer is 1", 0x3, type.
getType());
// 9952
el.
addTag("layer",
"+1");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("9952 layer is +1", 0x3, type.
getType());
}
@Test
public void testMultipleActions
() {
String rstr =
"highway=footway {add access = no; add foot = yes} [0x16 road_class=0 road_speed=0 resolution 23]";
RuleSet rs = makeRuleSet
(rstr
);
Element el =
new Way
(1);
el.
addTag("highway",
"footway");
getFirstType
(rs, el
);
assertEquals
("access set",
"no", el.
getTag("access"));
assertEquals
("access set",
"yes", el.
getTag("foot"));
}
/**
* You can now have a wild card at the top level.
*/
@Test
public void testWildcardTop
() {
RuleSet rs = makeRuleSet
("highway=* {set a=fred} [0x1]\n");
assertNotNull
("rule found", rs
);
Element el =
new Way
(1);
el.
addTag("highway",
"secondary");
GType type = getFirstType
(rs, el
);
assertNotNull
("can find match", type
);
assertEquals
("correct type",
1, type.
getType());
assertEquals
("tag set",
"fred", el.
getTag("a"));
}
/**
* Deal with cases such as
* (a = b | a = c) & d!=*
* where there is no key at the top level. This gets converted
* to: (a=b & d!=*) | (a=c & d!= *) which can then be used.
*
* This is applied recursively, so you can have chains of any length.
*/
@Test
public void testLeftSideOr
() {
RuleSet rs = makeRuleSet
("(a = b | a = c | a=d) & e!=* [0x2]" +
"a=c & e!=* [0x1]");
assertNotNull
("a=b chain", rs
);
assertNotNull
("a=c chain", rs
);
assertNotNull
("a=d chain", rs
);
// get the a=c chain and look at it more closely
Element el =
new Way
(1);
el.
addTag("a",
"c");
GType type = getFirstType
(rs, el
);
assertNotNull
("match e not existing", type
);
assertEquals
("correct type",
2, type.
getType());
el =
new Way
(2);
el.
addTag("a",
"d");
assertNotNull
("match e not existing", type
);
assertEquals
("correct type",
2, type.
getType());
}
/**
* You can now have a wild card at the top level, here we have & between
* two of them.
*/
@Test
public void testWildcard2
() {
RuleSet rs = makeRuleSet
("highway=* & z=* {set a=square} [0x1]\n");
assertNotNull
("rule found", rs
);
Element el =
new Way
(1);
el.
addTag("highway",
"secondary");
GType type = getFirstType
(rs, el
);
assertNull
("type not found with no z tag", type
);
// now add z
el.
addTag("z",
"1");
type = getFirstType
(rs, el
);
assertNotNull
("found match", type
);
assertEquals
("correct type",
1, type.
getType());
assertEquals
("tag set",
"square", el.
getTag("a"));
}
/**
* Tests for the road classification and other parts of the GType.
*/
@Test
public void testGType
() {
RuleSet rs = makeRuleSet
("highway=motorway " +
"[0x1 road_class=4 road_speed=7 default_name='motor way']\n");
Element el =
new Way
(1);
el.
addTag("highway",
"motorway");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
// Check that the correct class and speed are returned.
assertEquals
("class",
4, type.
getRoadClass());
assertEquals
("class",
7, type.
getRoadSpeed());
assertEquals
("default name",
"motor way", type.
getDefaultName());
}
/**
* Check for the regexp handling.
*/
@Test
public void testRegexp
() {
RuleSet rs = makeRuleSet
("highway=* & name ~ 'blue.*' [0x2]\n");
assertNotNull
("rule found", rs
);
// Set up element with matching name
Element el =
new Way
(1);
el.
addTag("highway",
"secondary");
el.
addTag("name",
"blue sq");
GType type = getFirstType
(rs, el
);
assertNotNull
("matched regexp", type
);
assertEquals
("matched type",
2, type.
getType());
// change name to one that should not match
el.
addTag("name",
"yellow");
type = getFirstType
(rs, el
);
assertNull
("no match for yello", type
);
}
@Test
public void testRegex2
() {
RuleSet rs = makeRuleSet
("a=b & (smoothness ~ '.*(bad|horrible|impassable)' | sac_scale ~ '.*(mountain|alpine)_hiking') [0x1]" +
"a = '>=' & b = '>' [0x2]");
assertNotNull
(rs
);
Element el =
new Way
(1);
el.
addTag("a",
"b");
el.
addTag("smoothness",
"zzzbad");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("matched .*bad",
1, type.
getType());
el =
new Way
(1);
el.
addTag("a",
"b");
el.
addTag("sac_scale",
"zzz alpine_hiking");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
el =
new Way
(1);
el.
addTag("a",
"b");
el.
addTag("sac_scale",
"zzz alp_hiking");
type = getFirstType
(rs, el
);
assertNull
(type
);
el =
new Way
(1);
el.
addTag("a",
">=");
el.
addTag("b",
">");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("match string that is the same as an operator",
2, type.
getType());
}
/**
* Some operations could not originally be used by themselves but now they are converted
* into expressions that can be handled automatically. The following few tests verify this.
*/
@Test
public void testRegexAtTop
() {
RuleSet rs = makeRuleSet
("QUOTA ~ ' [05]00\\.0+' [0x2]");
Element el =
new Way
(1);
el.
addTag("QUOTA",
" 500.0");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
@Test
(expected = SyntaxException.
class)
public void testNEAtTop
() {
RuleSet rs = makeRuleSet
("QUOTA != 'fred' [0x2]");
Element el =
new Way
(1);
el.
addTag("QUOTA",
"tom");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
@Test
public void testNEAtTopWithRE
() {
RuleSet rs = makeRuleSet
("a != 'fred' & a ~ '.*' [0x2]");
Element el =
new Way
(1);
el.
addTag("a",
"tom");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
@Test
public void testNumberOpAtTop
() {
RuleSet rs = makeRuleSet
("QUOTA > 10 [0x1] QUOTA < 6 [0x2]");
Element el =
new Way
(1);
el.
addTag("QUOTA",
"2");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
/**
* Failure of the optimiser to promote the correct term to the front.
* Example from mailing list.
*/
@Test
public void testOptimizeWithOr
() {
String s =
"highway ~ '(secondary|tertiary|unclassified|residential|minor|living_street|service)' " +
"& oneway=* " +
"& (cycleway=opposite | cycleway=opposite_lane | cycleway=opposite_track )" +
"[0x2 ]";
RuleSet rs = makeRuleSet
(s
);
Element el =
new Way
(1);
el.
addTag("highway",
"tertiary");
el.
addTag("oneway",
"1");
el.
addTag("cycleway",
"opposite_track");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
el.
addTag("cycleway",
"fred");
type = getFirstType
(rs, el
);
assertNull
(type
);
el.
addTag("cycleway",
"opposite");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
el = el.
copy(); // Copy for LinkedOp which remembers the last matched element
el.
addTag("cycleway",
"opposite_lane");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
el.
addTag("highway",
"fred");
type = getFirstType
(rs, el
);
assertNull
(type
);
}
/**
* Test is a simplified version of a rule in the floodblocker style.
*/
@Test
public void testOptimizeWithOr2
() {
String s =
"highway=*" +
"& tunnel!=*" +
"& (layer!=* | layer=0)" +
" [0x02]\n"
;
RuleSet rs = makeRuleSet
(s
);
Element el =
new Way
(1);
el.
addTag("highway",
"primary");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
el.
addTag("layer",
"0");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
el.
addTag("layer",
"1");
type = getFirstType
(rs, el
);
assertNull
(type
);
}
@Test
public void testOptimizeWithOr3
() throws Exception {
String s =
"highway=* & bridge!=* & " +
" (mtb:scale>0 | mtb:scale='0+' | tracktype ~ 'grade[2-6]' |" +
" sac_scale ~ '.*(mountain|alpine)_hiking' |" +
" sport=via_ferrata) [0x3]";
RuleSet rs = makeRuleSet
(s
);
Element el =
new Way
(1);
el.
addTag("highway",
"primary");
el.
addTag("mtb:scale",
"0+");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
}
/**
* This simply is to make sure that actions that affect their own
* conditions do not hang. There are no defined semantics for this.
*/
@Test
public void testSelfReference
() {
RuleSet rs = makeRuleSet
("iii=* { set iii=no }");
//Rule rule = rs.getMap().get("foot=*");
Way el =
new Way
(1);
el.
addTag("foot",
"yes");
el.
addTag("iii",
"xyz");
getFirstType
(rs, el
);
}
/**
* Test the not operator.
*/
@Test
public void testNot
() {
RuleSet rs = makeRuleSet
("tunnel=yes & !(route=mtb | route=bicycle) [0x1]");
//RuleSet rs = makeRuleSet("tunnel=yes & (route!=mtb & route!=bicycle) [0x1]");
Way el =
new Way
(1);
el.
addTag("tunnel",
"yes");
el.
addTag("route",
"abc");
getFirstType
(rs, el
);
}
@Test
public void testGTR
() {
RuleSet rs = makeRuleSet
("z=0 & a >= 10 [0x1]");
Way el =
new Way
(1);
el.
addTag("z",
"0");
el.
addTag("a",
"9");
GType type = getFirstType
(rs, el
);
assertNull
("a less that 10, no result", type
);
el.
addTag("a",
"10");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("Valid type returned",
1, type.
getType());
el.
addTag("a",
"11");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("Valid type returned",
1, type.
getType());
}
@Test
public void testLTE
() {
RuleSet rs = makeRuleSet
("z=0 & a <= 10 [0x1]");
Way el =
new Way
(1);
el.
addTag("z",
"0");
el.
addTag("a",
"9");
GType type = getFirstType
(rs, el
);
assertNotNull
("a less that 10", type
);
assertEquals
("found type for a <= 10",
1, type.
getType());
el.
addTag("a",
"10");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("Found type for a == 10",
1, type.
getType());
el.
addTag("a",
"11");
type = getFirstType
(rs, el
);
assertNull
("a is 11, a <= 10 is false", type
);
}
@Test
public void testNE
() {
RuleSet rs = makeRuleSet
("z=0 & a != 10 [0x1]");
Way el =
new Way
(1);
el.
addTag("z",
"0");
el.
addTag("a",
"9");
GType type = getFirstType
(rs, el
);
assertNotNull
("a is 9 so a!=10 is true", type
);
el.
addTag("a",
"10");
type = getFirstType
(rs, el
);
assertNull
("a is 10, so a!=10 is false", type
);
}
/**
* Test values such as 3.5 in comparisons.
* Originally non-integer values were not allowed and were not even recognised.
*/
@Test
public void testDecimalValues
() {
RuleSet rs = makeRuleSet
("z=yes & a < 3.5 [0x1]");
Way el =
new Way
(1);
el.
addTag("z",
"yes");
// Is less than so
el.
addTag("a",
"2");
GType type = getFirstType
(rs, el
);
assertNotNull
("a is less than 3.5", type
);
el.
addTag("a",
"4");
type = getFirstType
(rs, el
);
assertNull
("a is greater than 3.5", type
);
}
@Test
public void testDecimalAndDecimalCompare
() {
RuleSet rs = makeRuleSet
("z=yes & a < 3.5 [0x1]");
Way el =
new Way
(1);
el.
addTag("z",
"yes");
// Is less than so
el.
addTag("a",
"3.49");
GType type = getFirstType
(rs, el
);
assertNotNull
("a is less than 3.5", type
);
el.
addTag("a",
"3.55");
type = getFirstType
(rs, el
);
assertNull
("a is greater than 3.5", type
);
}
/**
* A moderately complex set of conditions and substitutions.
*/
@Test
public void testMtbRules
() {
RuleSet rs = makeRuleSet
(
"(mtb:scale=* | mtb:scale:uphill=*) & route=mtb" +
"{ name 'mtbrt${mtb:scale|def:.}${mtb:scale:uphill|def:.} ${name}' " +
" | 'mtbrt${mtb:scale|def:.}${mtb:scale:uphill|def:.}' }" +
" (mtb:scale=* | mtb:scale:uphill=*) & route!=mtb " +
"{ name 'mtb${mtb:scale|def:.}${mtb:scale:uphill|def:.} ${name}' " +
" | 'mtb${mtb:scale|def:.}${mtb:scale:uphill|def:.}' }"
);
Way el =
new Way
(1);
el.
addTag("route",
"mtb");
el.
addTag("mtb:scale",
"2");
getFirstType
(rs, el
);
assertEquals
("mtbrt2.", el.
getName());
el =
new Way
(1);
el.
addTag("route",
"mtb");
el.
addTag("mtb:scale:uphill",
"3");
getFirstType
(rs, el
);
assertEquals
("mtbrt.3", el.
getName());
el =
new Way
(1);
el.
addTag("name",
"myname");
el.
addTag("route",
"mtb");
el.
addTag("mtb:scale:uphill",
"3");
getFirstType
(rs, el
);
assertEquals
("mtbrt.3 myname", el.
getName());
el =
new Way
(1);
el.
addTag("mtb:scale:uphill",
"3");
getFirstType
(rs, el
);
assertEquals
("mtb.3", el.
getName());
}
/**
* Appending to an existing tag.
*/
@Test
public void testTagAppend
() {
RuleSet rs = makeRuleSet
(
"highway=*{set fullname='${ref}';" +
"set fullname='${fullname} ${name}';" +
"set fullname='${fullname} ${name1}';" +
"set fullname='${fullname} ${name2}';" +
"name '${fullname}'}"
);
Way el =
new Way
(1);
el.
addTag("highway",
"road");
el.
addTag("ref",
"A1");
el.
addTag("name",
"long lane");
el.
addTag("name1",
"foo");
el.
addTag("name2",
"bar");
getFirstType
(rs, el
);
assertEquals
("appended name",
"A1 long lane foo bar", el.
getName());
}
@Test
public void testExists
() {
RuleSet rs = makeRuleSet
("highway=* & maxspeed=40 {set mcssl=40}" +
"highway=primary & mcssl=40 [0x2 ]" +
"highway=* & mcssl=40 [0x3]");
Way el =
new Way
(1);
el.
addTag("ref",
"A123");
el.
addTag("name",
"Long Lane");
el.
addTag("highway",
"primary");
el.
addTag("maxspeed",
"40");
GType type = getFirstType
(rs, el
);
assertNotNull
("finds the type", type
);
assertEquals
("resulting type",
2, type.
getType());
}
/**
* Test the continue keyword. If a type is marked with this word, then
* further matches are performed and this might result in more types
* being added.
*/
@Test
public void testContinue
() {
RuleSet rs = makeRuleSet
("highway=primary [0x1 continue]" +
"highway=primary [0x2 continue]" +
"highway=primary [0x3]" +
"highway=primary [0x4]"
);
Way el =
new Way
(1);
el.
addTag("highway",
"primary");
final List<GType
> list =
new ArrayList<>();
rs.
resolveType(el,
new TypeResult
() {
public void add
(Element el, GType type
) {
list.
add(type
);
}
});
GType type = list.
get(0);
assertEquals
("first type",
1, type.
getType());
assertEquals
("continue search",
true, type.
isContinueSearch());
assertEquals
("number of result types",
3, list.
size());
assertEquals
("type of first",
1, list.
get(0).
getType());
assertEquals
("type of second",
2, list.
get(1).
getType());
assertEquals
("type of third",
3, list.
get(2).
getType());
}
@Test
public void testContinueRepeat
() {
RuleSet rs = makeRuleSet
("highway=primary [0x1 continue]" +
"highway=primary [0x2 continue]" +
"highway=primary [0x3]" +
"highway=primary [0x4]"
);
Way el =
new Way
(1);
el.
addTag("highway",
"primary");
for (int i =
0; i
< 3; i++
) {
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
("first type",
1, type.
getType());
assertEquals
("continue search",
true, type.
isContinueSearch());
}
}
/**
* The main point of this test is to ensure that all the examples compile.
*/
@Test
public void testComplexRegex
() {
RuleSet rs = makeRuleSet
(
//"a~b [0x0]" +
"a~b & c=d [0x1]" +
"a~b & c~d & e=f [0x2]" +
"(a~b | c~d) & e=f [0x3]" +
"(a~b | c~d) & e=f & g=h [0x4]" +
"((a~b | c~d) & e=f) & g=h [0x5]" +
"e=f & g=h & (a~b | c~'d.*') [0x6]" +
"(e=f & g=h) & (a~b | c~'d.*') [0x7]" +
"a=* & b=* & c=d [0x8]" +
"a=* & (b=* | c=d) [0x9]" +
""
);
Way el =
new Way
(1);
el.
addTag("c",
"df");
el.
addTag("g",
"h");
el.
addTag("e",
"f");
GType type = getFirstType
(rs, el
);
assertNotNull
("matches a rule", type
);
}
@Test
public void testTagsUsed
() {
RuleSet rs = makeRuleSet
("highway=primary & surface=good [0x1]" +
"A=B | C=D & E~'f.*' & G!=9 & K=* & L!=* [0x2]");
Set<String> tags = rs.
getUsedTags();
assertEquals
("number of tags used",
8, tags.
size());
assertTrue
("has highway", tags.
contains("highway"));
assertTrue
("has surface", tags.
contains("surface"));
assertTrue
("has A", tags.
contains("A"));
assertTrue
("has C", tags.
contains("C"));
assertTrue
("has E", tags.
contains("E"));
assertTrue
("has G", tags.
contains("G"));
assertTrue
("has K", tags.
contains("K"));
assertTrue
("has L", tags.
contains("L"));
}
/**
* There is a case where a tag is only used in an action but not in any
* expression. If we dropped the tags it would not be available for the
* action. A typical example might be name.
*/
@Test
public void testTagsUsedInActions
() {
RuleSet rs = makeRuleSet
("A=B { set t='${C}'; add t='${D} p ${E}'; name '${F} ${G}'; rename K L");
Set<String> tags = rs.
getUsedTags();
assertTrue
("has A", tags.
contains("A"));
assertTrue
("has C", tags.
contains("C"));
assertTrue
("has D", tags.
contains("D"));
assertTrue
("has E", tags.
contains("E"));
assertTrue
("has F", tags.
contains("F"));
assertTrue
("has G", tags.
contains("G"));
assertTrue
("has K", tags.
contains("K"));
}
@Test
public void testIncludeAsTagName
() {
RuleSet rs = makeRuleSet
("include=yes [0x2]");
Way way =
new Way
(1);
way.
addTag("include",
"yes");
GType type = getFirstType
(rs, way
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
@Test
public void testIncludeAsTagName2
() {
RuleSet rs = makeRuleSet
("include = yes [0x2]");
Way way =
new Way
(1);
way.
addTag("include",
"yes");
GType type = getFirstType
(rs, way
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
@Test
public void testIncludeFile
() {
StyleFileLoader loader =
new StringStyleFileLoader
(new String[][] {
{"lines",
"include incfile;"},
{"incfile",
"highway=secondary [0x3]"},
});
RuleSet rs = makeRuleSet
(loader
);
Element el =
new Way
(1);
el.
addTag("highway",
"secondary");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(3, type.
getType());
}
@Test
public void testIncludeFileQuoted
() {
StyleFileLoader loader =
new StringStyleFileLoader
(new String[][] {
{"lines",
"include \n 'inc file' \n;"},
{"inc file",
"highway=secondary [0x3]"},
});
RuleSet rs = makeRuleSet
(loader
);
Element el =
new Way
(1);
el.
addTag("highway",
"secondary");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(3, type.
getType());
}
/**
* Test an include file within an include file.
*/
@Test
public void testNestedIncludes
() {
StyleFileLoader loader =
new StringStyleFileLoader
(new String[][] {
{"lines",
"a=1 [0x1] include 'first'; a=2 [0x2]"},
{"first",
"b=1 [0x1] include 'second'; b=2 [0x2 ]"},
{"second",
"c=1 [0x1] c=2 [0x2 ]"},
});
RuleSet rs = makeRuleSet
(loader
);
Element el =
new Way
(1);
el.
addTag("a",
"2");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
el =
new Way
(2);
el.
addTag("c",
"1");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(1, type.
getType());
el =
new Way
(2);
el.
addTag("c",
"2");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
/**
* Bug when the first statement of an include file is itself an include statement.
* As luck would have the test tested the supposedly more difficult case of an
* include statement in the middle of the file.
*/
@Test
public void testNestedIncludeAndImmediateInclude
() {
StyleFileLoader loader =
new StringStyleFileLoader
(new String[][] {
{"lines",
"a=1 [0x1] include 'first'; a=2 [0x2]"},
{"first",
"include 'second'; b=2 [0x2 ]"},
{"second",
"c=1 [0x1] c=2 [0x2 ]"},
});
RuleSet rs = makeRuleSet
(loader
);
Element el =
new Way
(1);
el.
addTag("a",
"2");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
el =
new Way
(2);
el.
addTag("c",
"1");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(1, type.
getType());
el =
new Way
(2);
el.
addTag("c",
"2");
type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(2, type.
getType());
}
@Test
public void testIncludeFrom
() {
// NOTE: this test uses the default style, which could change.
StyleFileLoader loader =
new StringStyleFileLoader
(new String[][] {
{"lines",
"include 'lines' from default;\n"},
});
RuleSet rs = makeRuleSet
(loader
);
Way way =
new Way
(1);
way.
addTag("highway",
"motorway");
GType type = getFirstType
(rs, way
);
assertNotNull
("Check type not null", type
);
assertEquals
(1, type.
getType());
}
@Test
public void testLengthFunction
() {
// Its less than 92m
RuleSet rs = makeRuleSet
("A=B & length() < 92 [0x5]");
Way el = getWayWithLength
();
el.
addTag("A",
"B");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
}
@Test
public void testLengthFunction2
() {
// Its more than 91m
RuleSet rs = makeRuleSet
("A=B & length() > 91 [0x5]");
Way el = getWayWithLength
();
el.
addTag("A",
"B");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
}
@Test
public void testFunctionWithSpaces
() {
RuleSet rs = makeRuleSet
("A=B & length ( \n) > 91 & length\n()\n < 92 [0x5]");
Way el = getWayWithLength
();
el.
addTag("A",
"B");
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
}
@Test
(expected = SyntaxException.
class)
public void testFunctionWithParameters
() {
// a parameter in a function is not allowed yet
// this should throw a SyntaxException
makeRuleSet
("A=B & length(a) > 91 [0x5]");
assertTrue
("Function with parameters are not allowed",
false);
}
@Test
public void testIsClosedFunction
() {
RuleSet rs = makeRuleSet
("A=B & is_closed() = true [0x5]");
Way el = getWayForClosedCompleteCheck
(true,
true);
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
Way el2 = getWayForClosedCompleteCheck
(false,
true);
RuleSet rs2 = makeRuleSet
("A=B & is_closed() = false [0x5]");
GType type2 = getFirstType
(rs2, el2
);
assertNotNull
(type2
);
assertEquals
(5, type2.
getType());
}
@Test
public void testIsCompleteFunction
() {
RuleSet rs = makeRuleSet
("A=B & is_complete() = true [0x5]");
Way el = getWayForClosedCompleteCheck
(false,
true);
GType type = getFirstType
(rs, el
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
Way el2 = getWayForClosedCompleteCheck
(false,
false);
RuleSet rs2 = makeRuleSet
("A=B & is_complete() = false [0x5]");
GType type2 = getFirstType
(rs2, el2
);
assertNotNull
(type2
);
assertEquals
(5, type2.
getType());
}
@Test
(expected=SyntaxException.
class)
public void testNoFunctionParameters
() {
// a parameter in a function is not allowed for the length() function
// this should throw a SyntaxException
makeRuleSet
("A=B & length(a) > 91 [0x5]");
assertTrue
("Function with parameters are not allowed",
false);
}
/** You can't use length as the only term */
@Test
(expected=SyntaxException.
class)
public void testStandAloneLength
() {
// The length function is not allowed by itself, should be a syntax exception
makeRuleSet
("length() > 91 [0x5]");
}
@Test
(expected = SyntaxException.
class)
public void testFunctionDoesNotExist
() {
makeRuleSet
("A=B & non_existing_function() > 10 [0x5]");
}
/**
* Functions can be restricted to certain files. Eg length() does not make sense on a point.
*/
@Test
(expected = SyntaxException.
class)
public void testLengthInPoints
() {
StringStyleFileLoader loader =
new StringStyleFileLoader
(new String[][] {
{"points",
"A=B & length() < 100"}
});
RuleSet rs =
new RuleSet
();
RuleFileReader rr =
new RuleFileReader
(FeatureKind.
POINT,
LevelInfo.
createFromString("0:24 1:20 2:18 3:16 4:14"),
rs,
false,
null);
try {
rr.
load(loader,
"points");
} catch (FileNotFoundException e
) {
throw new AssertionError("Failed to open file: lines");
}
}
/**
* A test between something that is not not a value should be caught as a syntax
* error.
*/
@Test
(expected = SyntaxException.
class)
public void testWithNonValue
() {
RuleSet rs = makeRuleSet
("c=b & a=!* [0x5]");
Way w = getWayWithLength
();
w.
addTag("c",
"b");
getFirstType
(rs, w
);
}
@Test
(expected = SyntaxException.
class)
public void testLessThanWithNonValue
() {
RuleSet rs = makeRuleSet
("c=b & a<!* [0x5]");
Way w = getWayWithLength
();
w.
addTag("c",
"b");
getFirstType
(rs, w
);
}
/**
* Test the syntax to get a tag value on the RHS of the expression.
*/
@Test
public void testGetTagValueEquality
() {
RuleSet rs = makeRuleSet
("a=b & a=$c [0x5] a=b [0x6]");
Way w =
new Way
(1);
w.
addTag("a",
"b");
w.
addTag("c",
"b");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
w.
addTag("c",
"x");
type = getFirstType
(rs, w
);
assertNotNull
(type
);
assertEquals
(6, type.
getType());
}
@Test
public void testGetTagValueNotFound
() {
RuleSet rs = makeRuleSet
("a=b & b<$c [0x5] a=b [0x6]");
Way w =
new Way
(1);
w.
addTag("a",
"b");
w.
addTag("b",
"50");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
assertEquals
(6, type.
getType());
}
@Test
public void testGetTagValueAlone
() {
RuleSet rs = makeRuleSet
("a<$b [0x5] a=b [0x6]");
Way w =
new Way
(1);
w.
addTag("a",
"1");
w.
addTag("b",
"2");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
}
@Test
public void testValueTagValue
() {
RuleSet rs = makeRuleSet
("a=$b [0x5]");
Way w =
new Way
(1);
w.
addTag("a",
"2");
w.
addTag("b",
"2");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
assertEquals
(5, type.
getType());
}
@Test
public void test_X3NOT_Error
() {
// Bug caused an Error: X3:NOT syntax exception to be thrown.
RuleSet rs = makeRuleSet
("(a=1 | b=2) & !(c=1) & d!=3 [0x8]");
Way w =
new Way
(1);
w.
addTag("b",
"1");
GType type = getFirstType
(rs, w
);
assertNull
(type
);
w.
addTag("b",
"2");
type = getFirstType
(rs, w
);
assertNotNull
(type
);
w.
addTag("d",
"3");
type = getFirstType
(rs, w
);
assertNull
(type
);
w.
addTag("d",
"2");
type = getFirstType
(rs, w
);
assertNotNull
(type
);
}
@Test
public void testBugOrWithAndOnLeft
() {
RuleSet rs = makeRuleSet
("((a=1&b=2) | a=2) & c!=4 [0x2]");
Way w =
new Way
(1);
w.
addTag("a",
"2");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
}
@Test
public void testBugOrWithAndOnLeft2
() {
RuleSet rs = makeRuleSet
("(((a=1 | a=5)&b=2) | a=2) & c!=4 [0x2]");
Way w =
new Way
(1);
w.
addTag("a",
"2");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
assertEquals
(type.
getType(),
2);
}
@Test
public void testBugOr
() {
String s =
"maxspeed=*\n" +
" & ( maxspeedkmh()>120 | maxspeed = none )\n" +
" & ( highway = motorway | highway = trunk )\n" +
"[0x4]\n";
RuleSet rs = makeRuleSet
(s
);
Way w =
new Way
(1);
w.
addTag("highway",
"trunk");
w.
addTag("maxspeed",
"122");
GType type = getFirstType
(rs, w
);
assertNotNull
(type
);
}
/**
* Get a way with a few points for testing length.
*
* The length of this segment was independently confirmed to be around 91m.
*/
private Way getWayWithLength
() {
Way el =
new Way
(1);
el.
addPoint(new Coord
(51.6124376, -
0.1777185));
el.
addPoint(new Coord
(51.6127816, -
0.1775029));
el.
addPoint(new Coord
(51.6132048, -
0.1772467));
return el
;
}
/**
* Get a way with a few points for testing the closed and complete flag.
* @param closed way should be closed
* @param complete way should not be complete
*/
private Way getWayForClosedCompleteCheck
(boolean closed,
boolean complete
) {
Way el =
new Way
(1);
el.
addTag("A",
"B");
el.
addPoint(new Coord
(1000,
1000));
el.
addPoint(new Coord
(1000,
2000));
el.
addPoint(new Coord
(2000,
2000));
el.
addPoint(new Coord
(2000,
1000));
if (closed
)
el.
addPoint(el.
getFirstPoint());
el.
setComplete(complete
);
el.
setClosedInOSM(true);
return el
;
}
/**
* Resolve the rule set with the given element and get the first
* resolved type.
*/
private GType getFirstType
(Rule rs,
Element el
) {
final List<GType
> types =
new ArrayList<>();
rs.
resolveType(el,
(element, type
) -
> types.
add(type
));
if (types.
isEmpty())
return null;
else
return types.
get(0);
}
}