506 lines
16 KiB
Go
506 lines
16 KiB
Go
package mapping
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/omniscale/imposm3/element"
|
|
)
|
|
|
|
var mapping *Mapping
|
|
|
|
func init() {
|
|
var err error
|
|
mapping, err = NewMapping("./test_mapping.yml")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func stringMapEquals(t *testing.T, expected, actual map[string]string) {
|
|
if len(expected) != len(actual) {
|
|
t.Fatalf("different length in %v and %v\n", expected, actual)
|
|
}
|
|
|
|
for k, v := range expected {
|
|
if actualV, ok := actual[k]; ok {
|
|
if actualV != v {
|
|
t.Fatalf("%s != %s in %v and %v\n", v, actualV, expected, actual)
|
|
}
|
|
} else {
|
|
t.Fatalf("%s not in %v\n", k, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func matchesEqual(t *testing.T, expected []Match, actual []Match) {
|
|
expectedMatches := make(map[DestTable]Match)
|
|
actualMatches := make(map[DestTable]Match)
|
|
|
|
if len(expected) != len(actual) {
|
|
t.Fatalf("different length in %v and %v\n", expected, actual)
|
|
}
|
|
|
|
for _, match := range expected {
|
|
expectedMatches[match.Table] = match
|
|
}
|
|
for _, match := range actual {
|
|
actualMatches[match.Table] = match
|
|
}
|
|
|
|
for name, expectedMatch := range expectedMatches {
|
|
if actualMatch, ok := actualMatches[name]; ok {
|
|
if expectedMatch.Table != actualMatch.Table ||
|
|
expectedMatch.Key != actualMatch.Key ||
|
|
expectedMatch.Value != actualMatch.Value {
|
|
t.Fatalf("match differ %v != %v", expectedMatch, actualMatch)
|
|
}
|
|
} else {
|
|
t.Fatalf("%s not in %v", name, actualMatches)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTagFilterNodes(t *testing.T) {
|
|
var tags element.Tags
|
|
nodes := mapping.NodeTagFilter()
|
|
|
|
tags = element.Tags{"name": "foo"}
|
|
if nodes.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "unknown": "baz"}
|
|
if nodes.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "place": "unknown"}
|
|
if nodes.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "place": "village"}
|
|
if nodes.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "place": "village"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "place": "village", "population": "1000"}
|
|
if nodes.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "place": "village", "population": "1000"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "place": "village", "highway": "unknown"}
|
|
if nodes.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "place": "village"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "place": "village", "highway": "bus_stop"}
|
|
if nodes.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "place": "village", "highway": "bus_stop"}, tags)
|
|
}
|
|
|
|
func TestTagFilterWays(t *testing.T) {
|
|
var tags element.Tags
|
|
ways := mapping.WayTagFilter()
|
|
|
|
tags = element.Tags{"name": "foo"}
|
|
if ways.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "unknown": "baz"}
|
|
if ways.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "highway": "unknown"}
|
|
if ways.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "highway": "track"}
|
|
if ways.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "highway": "track"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "highway": "track", "oneway": "yes", "tunnel": "1"}
|
|
if ways.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "highway": "track", "oneway": "yes", "tunnel": "1"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "place": "village", "highway": "track"}
|
|
if ways.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "highway": "track"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "railway": "tram", "highway": "secondary"}
|
|
if ways.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "railway": "tram", "highway": "secondary"}, tags)
|
|
|
|
// with __any__ value
|
|
tags = element.Tags{"name": "foo", "building": "yes"}
|
|
if ways.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "building": "yes"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "building": "whatever"}
|
|
if ways.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "building": "whatever"}, tags)
|
|
}
|
|
|
|
func TestTagFilterRelations(t *testing.T) {
|
|
var tags element.Tags
|
|
relations := mapping.RelationTagFilter()
|
|
|
|
tags = element.Tags{"name": "foo"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "unknown": "baz"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "landuse": "unknown"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "landuse": "farm"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "landuse": "farm", "type": "multipolygon"}
|
|
if relations.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "landuse": "farm", "type": "multipolygon"}, tags)
|
|
|
|
// skip multipolygon with filtered tags, otherwise tags from
|
|
// longest way would be used
|
|
tags = element.Tags{"name": "foo", "landuse": "unknown", "type": "multipolygon"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "landuse": "park", "type": "multipolygon"}
|
|
if relations.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "type": "multipolygon", "landuse": "park"}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "landuse": "farm", "boundary": "administrative", "type": "multipolygon"}
|
|
if relations.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "landuse": "farm", "boundary": "administrative", "type": "multipolygon"}, tags)
|
|
|
|
// boundary relation for boundary
|
|
tags = element.Tags{"name": "foo", "landuse": "farm", "boundary": "administrative", "type": "boundary"}
|
|
if relations.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "landuse": "farm", "boundary": "administrative", "type": "boundary"}, tags)
|
|
|
|
// boundary relation for non boundary
|
|
tags = element.Tags{"name": "foo", "landuse": "farm", "type": "boundary"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
/* skip boundary with filtered tags, otherwise tags from longest way would
|
|
be used */
|
|
tags = element.Tags{"name": "foo", "boundary": "unknown", "type": "boundary"}
|
|
if relations.Filter(&tags) != false {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{}, tags)
|
|
|
|
tags = element.Tags{"name": "foo", "boundary": "administrative", "type": "boundary"}
|
|
if relations.Filter(&tags) != true {
|
|
t.Fatal("unexpected filter response for", tags)
|
|
}
|
|
stringMapEquals(t, element.Tags{"name": "foo", "boundary": "administrative", "type": "boundary"}, tags)
|
|
|
|
}
|
|
|
|
func TestPointMatcher(t *testing.T) {
|
|
elem := element.Node{}
|
|
points := mapping.PointMatcher()
|
|
|
|
elem.Tags = element.Tags{"unknown": "baz"}
|
|
matchesEqual(t, []Match{}, points.MatchNode(&elem))
|
|
|
|
elem.Tags = element.Tags{"place": "unknown"}
|
|
matchesEqual(t, []Match{}, points.MatchNode(&elem))
|
|
|
|
elem.Tags = element.Tags{"place": "city"}
|
|
matchesEqual(t, []Match{{"place", "city", DestTable{Name: "places"}, nil}}, points.MatchNode(&elem))
|
|
|
|
elem.Tags = element.Tags{"place": "city", "highway": "unknown"}
|
|
matchesEqual(t, []Match{{"place", "city", DestTable{Name: "places"}, nil}}, points.MatchNode(&elem))
|
|
|
|
elem.Tags = element.Tags{"place": "city", "highway": "bus_stop"}
|
|
matchesEqual(t,
|
|
[]Match{
|
|
{"place", "city", DestTable{Name: "places"}, nil},
|
|
{"highway", "bus_stop", DestTable{Name: "transport_points"}, nil}},
|
|
points.MatchNode(&elem))
|
|
}
|
|
|
|
func TestLineStringMatcher(t *testing.T) {
|
|
elem := element.Way{}
|
|
// fake closed way for area matching
|
|
elem.Refs = []int64{1, 2, 3, 4, 1}
|
|
if !elem.IsClosed() {
|
|
t.Fatal("way not closed")
|
|
}
|
|
ls := mapping.LineStringMatcher()
|
|
|
|
elem.Tags = element.Tags{"unknown": "baz"}
|
|
matchesEqual(t, []Match{}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"highway": "unknown"}
|
|
matchesEqual(t, []Match{}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"highway": "pedestrian"}
|
|
matchesEqual(t, []Match{{"highway", "pedestrian", DestTable{Name: "roads", SubMapping: "roads"}, nil}}, ls.MatchWay(&elem))
|
|
|
|
// exclude_tags area=yes
|
|
elem.Tags = element.Tags{"highway": "pedestrian", "area": "yes"}
|
|
matchesEqual(t, []Match{}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"barrier": "hedge"}
|
|
matchesEqual(t, []Match{{"barrier", "hedge", DestTable{Name: "barrierways"}, nil}}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"barrier": "hedge", "area": "yes"}
|
|
matchesEqual(t, []Match{}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"aeroway": "runway", "area": "no"}
|
|
matchesEqual(t, []Match{{"aeroway", "runway", DestTable{Name: "aeroways"}, nil}}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"aeroway": "runway"}
|
|
matchesEqual(t, []Match{}, ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"highway": "secondary", "railway": "tram"}
|
|
matchesEqual(t,
|
|
[]Match{
|
|
{"highway", "secondary", DestTable{Name: "roads", SubMapping: "roads"}, nil},
|
|
{"railway", "tram", DestTable{Name: "roads", SubMapping: "railway"}, nil}},
|
|
ls.MatchWay(&elem))
|
|
|
|
elem.Tags = element.Tags{"highway": "footway", "landuse": "park"}
|
|
// landusages not a linestring table
|
|
matchesEqual(t, []Match{{"highway", "footway", DestTable{Name: "roads", SubMapping: "roads"}, nil}}, ls.MatchWay(&elem))
|
|
}
|
|
|
|
func TestPolygonMatcher(t *testing.T) {
|
|
elem := element.Relation{}
|
|
polys := mapping.PolygonMatcher()
|
|
|
|
elem.Tags = element.Tags{"unknown": "baz"}
|
|
matchesEqual(t, []Match{}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"landuse": "unknowns"}
|
|
matchesEqual(t, []Match{}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"building": "yes"}
|
|
matchesEqual(t, []Match{{"building", "yes", DestTable{Name: "buildings"}, nil}}, polys.MatchRelation(&elem))
|
|
elem.Tags = element.Tags{"building": "residential"}
|
|
matchesEqual(t, []Match{{"building", "residential", DestTable{Name: "buildings"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"barrier": "hedge"}
|
|
matchesEqual(t, []Match{}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"barrier": "hedge", "area": "yes"}
|
|
matchesEqual(t, []Match{{"barrier", "hedge", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"building": "shop"}
|
|
matchesEqual(t, []Match{
|
|
{"building", "shop", DestTable{Name: "buildings"}, nil},
|
|
{"building", "shop", DestTable{Name: "amenity_areas"}, nil}},
|
|
polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"landuse": "farm"}
|
|
matchesEqual(t, []Match{{"landuse", "farm", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"landuse": "farm", "highway": "secondary"}
|
|
matchesEqual(t, []Match{{"landuse", "farm", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"landuse": "farm", "aeroway": "apron"}
|
|
matchesEqual(t,
|
|
[]Match{
|
|
{"aeroway", "apron", DestTable{Name: "transport_areas"}, nil},
|
|
{"landuse", "farm", DestTable{Name: "landusages"}, nil}},
|
|
polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"highway": "footway"} // linear by default
|
|
matchesEqual(t, []Match{}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"highway": "footway", "area": "yes"}
|
|
matchesEqual(t, []Match{{"highway", "footway", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"boundary": "administrative", "admin_level": "8"}
|
|
matchesEqual(t, []Match{{"boundary", "administrative", DestTable{Name: "admin"}, nil}}, polys.MatchRelation(&elem))
|
|
}
|
|
|
|
func TestMatcherMappingOrder(t *testing.T) {
|
|
elem := element.Relation{}
|
|
polys := mapping.PolygonMatcher()
|
|
|
|
/*
|
|
landusages mapping has the following order,
|
|
check that XxxMatcher always uses the first
|
|
|
|
amenity:
|
|
- university
|
|
landuse:
|
|
- forest
|
|
leisure:
|
|
- park
|
|
landuse:
|
|
- park
|
|
*/
|
|
|
|
elem.Tags = element.Tags{"landuse": "forest", "leisure": "park"}
|
|
matchesEqual(t, []Match{{"landuse", "forest", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"landuse": "park", "leisure": "park"}
|
|
matchesEqual(t, []Match{{"leisure", "park", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
|
|
elem.Tags = element.Tags{"landuse": "park", "leisure": "park", "amenity": "university"}
|
|
matchesEqual(t, []Match{{"amenity", "university", DestTable{Name: "landusages"}, nil}}, polys.MatchRelation(&elem))
|
|
}
|
|
|
|
func TestFilterNodes(t *testing.T) {
|
|
var tags element.Tags
|
|
|
|
// test name only
|
|
tags = make(element.Tags)
|
|
tags["name"] = "foo"
|
|
|
|
points := mapping.NodeTagFilter()
|
|
if points.Filter(&tags) != false {
|
|
t.Fatal("Filter result not false")
|
|
}
|
|
if len(tags) != 0 {
|
|
t.Fatal("Filter result not empty")
|
|
}
|
|
|
|
// test name + unmapped tags
|
|
tags = make(element.Tags)
|
|
tags["name"] = "foo"
|
|
tags["boring"] = "true"
|
|
|
|
if points.Filter(&tags) != false {
|
|
t.Fatal("Filter result not false")
|
|
}
|
|
if len(tags) != 0 {
|
|
t.Fatal("Filter result not empty")
|
|
}
|
|
|
|
// test fields only, but no mapping
|
|
tags = make(element.Tags)
|
|
tags["population"] = "0"
|
|
tags["name"] = "foo"
|
|
tags["boring"] = "true"
|
|
|
|
if points.Filter(&tags) != false {
|
|
t.Fatal("Filter result true", tags)
|
|
}
|
|
if len(tags) != 0 {
|
|
t.Fatal("Filter result not empty", tags)
|
|
}
|
|
|
|
// ... not with mapped tag (place)
|
|
tags = make(element.Tags)
|
|
tags["population"] = "0"
|
|
tags["name"] = "foo"
|
|
tags["boring"] = "true"
|
|
tags["place"] = "village"
|
|
|
|
if points.Filter(&tags) != true {
|
|
t.Fatal("Filter result true", tags)
|
|
}
|
|
if len(tags) != 3 && tags["population"] == "0" && tags["name"] == "foo" && tags["place"] == "village" {
|
|
t.Fatal("Filter result not expected", tags)
|
|
}
|
|
}
|
|
|
|
func TestExcludeFilter(t *testing.T) {
|
|
var f TagFilterer
|
|
var tags element.Tags
|
|
|
|
// no matches
|
|
f = newExcludeFilter([]Key{})
|
|
tags = element.Tags{"source": "1", "tiger:foo": "1", "source:foo": "1"}
|
|
f.Filter(&tags)
|
|
if !reflect.DeepEqual(tags, element.Tags{"source": "1", "tiger:foo": "1", "source:foo": "1"}) {
|
|
t.Error("unexpected filter result", tags)
|
|
}
|
|
|
|
// match all
|
|
f = newExcludeFilter([]Key{"*"})
|
|
tags = element.Tags{"source": "1", "tiger:foo": "1", "source:foo": "1"}
|
|
f.Filter(&tags)
|
|
if !reflect.DeepEqual(tags, element.Tags{}) {
|
|
t.Error("unexpected filter result", tags)
|
|
}
|
|
|
|
// fixed string and wildcard match
|
|
f = newExcludeFilter([]Key{"source", "tiger:*"})
|
|
tags = element.Tags{"source": "1", "tiger:foo": "1", "source:foo": "1"}
|
|
f.Filter(&tags)
|
|
if !reflect.DeepEqual(tags, element.Tags{"source:foo": "1"}) {
|
|
t.Error("unexpected filter result", tags)
|
|
}
|
|
}
|
|
|
|
func BenchmarkFilterNodes(b *testing.B) {
|
|
var tags element.Tags
|
|
|
|
for i := 0; i < b.N; i++ {
|
|
// test __any__
|
|
tags = make(element.Tags)
|
|
tags["population"] = "0"
|
|
tags["name"] = "foo"
|
|
tags["boring"] = "true"
|
|
|
|
points := mapping.NodeTagFilter()
|
|
if points.Filter(&tags) != true {
|
|
b.Fatal("Filter result true", tags)
|
|
}
|
|
if len(tags) != 2 && tags["population"] == "0" && tags["name"] == "foo" {
|
|
b.Fatal("Filter result not expected", tags)
|
|
}
|
|
}
|
|
}
|