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)