def test_happy(self) -> None:
"""Tests the happy path."""
with unittest.mock.patch('util.get_abspath', get_abspath):
relations = get_relations()
relation = relations.get_relation("gazdagret")
filters = relation.get_street_ranges()
expected_filters = {
"Budaörsi út":
ranges.Ranges([ranges.Range(137, 165)]),
"Csiki-hegyek utca":
ranges.Ranges([ranges.Range(1, 15),
ranges.Range(2, 26)]),
'Hamzsabégi út':
ranges.Ranges(
[ranges.Range(start=1, end=12, interpolation="all")])
}
self.assertEqual(filters, expected_filters)
expected_streets = {
'OSM Name 1': 'Ref Name 1',
'OSM Name 2': 'Ref Name 2'
}
relations = get_relations()
self.assertEqual(
relations.get_relation(
"gazdagret").get_config().get_refstreets(),
expected_streets)
street_blacklist = relations.get_relation(
"gazdagret").get_config().get_street_filters()
self.assertEqual(street_blacklist, ['Only In Ref Nonsense utca'])
def test_happy(self) -> None:
"""Tests the happy path."""
relations = areas.Relations(test_context.make_test_context())
relation = relations.get_relation("gazdagret")
filters = relation.get_street_ranges()
expected_filters = {
"Budaörsi út":
ranges.Ranges([make_range(137, 165)]),
"Csiki-hegyek utca":
ranges.Ranges([make_range(1, 15),
make_range(2, 26)]),
'Hamzsabégi út':
ranges.Ranges([ranges.Range(start=1, end=12, interpolation="all")])
}
self.assertEqual(filters, expected_filters)
expected_streets = {
'OSM Name 1': 'Ref Name 1',
'OSM Name 2': 'Ref Name 2',
'Misspelled OSM Name 1': 'OSM Name 1',
}
relations = areas.Relations(test_context.make_test_context())
self.assertEqual(
relations.get_relation("gazdagret").get_config().get_refstreets(),
expected_streets)
street_blacklist = relations.get_relation(
"gazdagret").get_config().get_street_filters()
self.assertEqual(street_blacklist, ['Only In Ref Nonsense utca'])
def testSubsetKnown(self):
"Test Ranges.subset() against some known values."
for l1, l2, res in self.knownSubsetValues:
r1 = ranges.Ranges()
r1.addlist(l1)
r2 = ranges.Ranges()
r2.addlist(l2)
self.assertEqual(r1.subset(r2), res)
def testAddSubRanges(self):
"Test that addRanges and delRanges work right."
for al, bl, ares, sres in self.knownAddSubs:
r1 = ranges.Ranges(al[0], al[1])
r2 = ranges.Ranges(bl[0], bl[1])
r1.addRanges(r2)
self.assertEqual(str(r1), ares)
r1.delRanges(r2)
self.assertEqual(str(r1), sres)
def testStrResults(self):
"Test the result of str() of a Ranges on known values."
self.assertEqual(str(ranges.Ranges()), "<Ranges: >")
self.assertEqual(str(ranges.Ranges(1, 10)), "<Ranges: 1-10>")
self.assertEqual(str(ranges.Ranges(1, 1)), "<Ranges: 1>")
r = ranges.Ranges()
r.addrange(5, 10)
r.addnum(1)
self.assertEqual(str(r), "<Ranges: 1 5-10>")
def testAdjacentFunc(self):
"Test Ranges.adjacent() with known values."
e = ranges.Ranges()
for al, bl, res in self.knownAdjacents:
r1 = ranges.Ranges(al[0], al[1])
r2 = ranges.Ranges(bl[0], bl[1])
self.assertEqual(r1.adjacent(r2), res)
# adjacency is reflexive
self.assertEqual(r2.adjacent(r1), res)
# An empty range should never be adjacent.
for r in (r1, r2):
self.assertEqual(e.adjacent(r), 0)
self.assertEqual(r.adjacent(e), 0)
def testAddSubFunc(self):
"Test that object addition and subtraction work."
e = ranges.Ranges()
for al, bl, ares, sres in self.knownAddSubs:
r1 = ranges.Ranges(al[0], al[1])
r2 = ranges.Ranges(bl[0], bl[1])
# Basic tests for operators.
for r in (r1, r2):
self.assertEqual(r == (r + r), 1)
self.assertEqual(e == (r - r), 1)
ra = r1 + r2
rs = r1 - r2
self.assertEqual(str(ra), ares)
self.assertEqual(str(rs), sres)
def testKnownInitfailures(self):
"Test that Ranges fail to initialize for certain known bad inputs."
self.assertRaises(TypeError, ranges.Ranges, 1, 2, 3, 4)
self.assertRaises(TypeError, ranges.Ranges, 1)
self.assertRaises(ranges.BadRange, ranges.Ranges, 10, 9)
r = ranges.Ranges()
self.assertRaises(ranges.BadRange, r.addrange, 10, 9)
self.assertRaises(ranges.BadRange, r.delrange, 10, 9)
def testIntersectBasics(self):
"Test for basic correctness of Ranges.intersect()."
e = ranges.Ranges()
# Empty ranges do not intersect each other.
# In fact, they intersect nothing.
self.assertEqual(e.intersect(e), 0)
for l1, l2, res in self.knownIntersectRanges:
r1 = ranges.Ranges()
r1.addlist(l1)
r2 = ranges.Ranges()
r2.addlist(l2)
# Empty set intersects neither.
self.assertEqual(e.intersect(r1), 0)
self.assertEqual(r2.intersect(e), 0)
# Test core operation.
self.assertEqual(r1.intersect(r2), res,
"failed on %s versus %s" % (str(r1), str(r2)))
self.assertEqual(r2.intersect(r1), res)
def testLenOperation(self):
"Test len(Ranges) for basic proper operation."
r = ranges.Ranges()
self.assertEqual(len(r), 0)
r.addnum(1)
self.assertEqual(len(r), 1)
r.addnum(2)
self.assertEqual(len(r), 2)
r.addrange(10, 15)
self.assertEqual(len(r), 8)
def get_normalizer(street_name: str, normalizers: Dict[str, ranges.Ranges]) -> ranges.Ranges:
"""Determines the normalizer for a given street."""
if street_name in normalizers.keys():
# Have a custom filter.
normalizer = normalizers[street_name]
else:
# Default sanity checks.
default = [ranges.Range(1, 999), ranges.Range(2, 998)]
normalizer = ranges.Ranges(default)
return normalizer
def testInOperator(self):
"""Test the 'in' operator of Ranges."""
r = ranges.Ranges(2, 10)
self.assertEqual(0 in r, 0)
self.assertEqual(2 in r, 1)
# Now, assert that every element in every one of our
# test lists above is in itself.
for elist, ign in self.knownAddValues:
r = ranges.Ranges()
r.addlist(elist)
for e in r:
self.assertEqual(e in r, 1)
# Another test; this is designed to test the binary
# search stuff.
rl = ((2, 10), (15, 17), (20, 25), (30, 35), (40, 45), (50, 60),
(70, 75), (80, 85), (90, 95), (100, 105), (110, 120), (125, 128),
(130, 135), (140, 150))
r = ranges.Ranges()
r.addlist(rl)
for i in (2, 10, 16, 20, 144, 91, 85):
self.assertEqual(i in r, 1)
for i in (1, 11, 151, 200, 0, 88):
self.assertEqual(i in r, 0)
def testSubsetOperator(self):
"Test Ranges.subset() for basic proper operation."
e = ranges.Ranges()
# we don't use negative range values so far.
mr = ranges.Ranges(-10, -5)
# An empty range should be the subset of itself.
self.assertEqual(e.subset(e), 1)
# Test basic reflexitivity on our magic values.
for il, res in self.knownAddValues:
r = ranges.Ranges()
r.addlist(il)
# ... because empty ranges are a subset of
# everything?
self.assertEqual(r.subset(e), 1)
# r should be a subset of itself?
self.assertEqual(r.subset(r), 1)
# mr should not be a subset.
self.assertEqual(r.subset(mr), 0)
# Add an out-of-range value and see if it is
# rejected.
r1 = r.copy()
r1.addnum(1000)
self.assertEqual(r.subset(r1), 0)
self.assertEqual(r1.subset(r), 1)
def get_street_ranges(self) -> Dict[str, ranges.Ranges]:
"""Gets a street name -> ranges map, which allows silencing false positives."""
filter_dict: Dict[str, ranges.Ranges] = {}
filters = self.get_config().get_filters()
for street in filters.keys():
interpolation = ""
if "interpolation" in filters[street]:
interpolation = filters[street]["interpolation"]
i = []
if "ranges" not in filters[street]:
continue
for start_end in filters[street]["ranges"]:
i.append(ranges.Range(int(start_end["start"]), int(start_end["end"]), interpolation))
filter_dict[street] = ranges.Ranges(i)
return filter_dict
def testAddSubValues(self):
"Test that adding up a series of ranges results in a known list and that subtracting them again yields an empty list."
for elist, rval in self.knownAddValues:
r = ranges.Ranges()
r.addlist(elist)
self.assertEqual(r._l, rval)
r.dellist(elist)
self.assertEqual(r._l, [])
# Now we check the stability of these results under
# inverting the order of both removals and then
# additions.
r.addlist(elist)
# Turn the elist tuple into a list so we can
# reverse it.
elist = list(elist)
elist.reverse()
# Delete it.
r.dellist(elist)
self.assertEqual(r._l, [])
# Add it back in to the null and assert that it is
# the same.
r.addlist(elist)
self.assertEqual(r._l, rval)
def test_ab(self) -> None:
"""Tests when the arg is in both ranges."""
test = ranges.Ranges([make_range(1, 1), make_range(1, 1)])
self.assertTrue(1 in test)
def test_a(self) -> None:
"""Tests when the arg is in the first range."""
test = ranges.Ranges([make_range(0, 0), make_range(1, 1)])
self.assertTrue(0 in test)
def test_b(self) -> None:
"""Tests when the arg is in the second range."""
test = ranges.Ranges([make_range(0, 0), make_range(1, 1)])
self.assertTrue(1 in test)
def test_none(self) -> None:
"""Tests when the arg is in neither ranges."""
test = ranges.Ranges([make_range(0, 0), make_range(1, 1)])
self.assertFalse(2 in test)
def normalize(relation: Relation, house_numbers: str, street_name: str,
normalizers: Dict[str, ranges.Ranges]) -> List[util.HouseNumber]:
"""Strips down string input to bare minimum that can be interpreted as an
actual number. Think about a/b, a-b, and so on."""
ret_numbers = []
# Same as ret_numbers, but if the range is 2-6 and we filter for 2-4, then 6 would be lost, so
# in-range 4 would not be detected, so this one does not drop 6.
ret_numbers_nofilter = []
if ';' in house_numbers:
separator = ';'
else:
separator = '-'
# Determine suffix which is not normalized away.
suffix = ""
if house_numbers.endswith("*"):
suffix = house_numbers[-1]
if street_name in normalizers.keys():
# Have a custom filter.
normalizer = normalizers[street_name]
else:
# Default sanity checks.
default = [ranges.Range(1, 999), ranges.Range(2, 998)]
normalizer = ranges.Ranges(default)
for house_number in house_numbers.split(separator):
try:
number = int(re.sub(r"([0-9]+).*", r"\1", house_number))
except ValueError:
continue
ret_numbers_nofilter.append(number)
if number not in normalizer:
continue
ret_numbers.append(number)
street_is_even_odd = relation.get_config().get_street_is_even_odd(
street_name)
if separator == "-" and util.should_expand_range(ret_numbers_nofilter,
street_is_even_odd):
start = ret_numbers_nofilter[0]
stop = ret_numbers_nofilter[1]
if stop == 0:
ret_numbers = [
number for number in [start] if number in normalizer
]
elif street_is_even_odd:
# Assume that e.g. 2-6 actually means 2, 4 and 6, not only 2 and 4.
# Closed interval, even only or odd only case.
ret_numbers = [
number for number in range(start, stop + 2, 2)
if number in normalizer
]
else:
# Closed interval, but mixed even and odd.
ret_numbers = [
number for number in range(start, stop + 1, 1)
if number in normalizer
]
return [
util.HouseNumber(str(number) + suffix, house_numbers)
for number in ret_numbers
]
def testIterOperation(self):
"Test that Ranges iteration yields known values."
for initlist, restup in self.knownIterValues:
r = ranges.Ranges()
r.addlist(initlist)
self.assertEqual(tuple(r), restup)
