def test_bug11_valid_union_call_detected_as_invalid(): """ `Bug #11 <https://github.com/runfalk/spans/issues/11>`_ """ start, middle, end = 0.0, 1.0, 2.0 a = floatrange(start, middle, upper_inc=True) b = floatrange(middle, end) assert a.union(b) == floatrange(start, end)
def test_difference_typecheck(): a = floatrange(1.0, 10.0) b = intrange(5, 10) with pytest.raises(TypeError): a.difference(b) assert a.__sub__(b) is NotImplemented
def test_intersection_typecheck(): a = floatrange(1.0, 5.0) b = intrange(5, 10) with pytest.raises(TypeError): a.intersection(b) assert a.__and__(b) is NotImplemented
def floatrange_preprocess(lower=None, upper=None, lower_inc=None, upper_inc=None): if lower is not None: lower = float(lower) if upper is not None: upper = float(upper) return floatrange(lower, upper, lower_inc, upper_inc)
def test_greater_than(): assert intrange(2, 5) > intrange(1, 5) assert intrange(1, 5) > intrange(1, 4) assert not intrange(1, 5) > intrange(1, 5) assert intrange(1, 5, upper_inc=True) > intrange(1, 5) assert intrange(1, 5, lower_inc=False) > intrange(1, 5) assert intrange(2) > intrange(1, 5) assert intrange(1, 5) >= intrange(1, 5) assert intrange(1, 5) >= intrange(1, 4) assert not intrange(1, 5) >= intrange(2, 5) # Hack used to work around version differences between Python 2 and 3. # Python 2 has its own idea of how objects compare to each other. # Python 3 raises type error when an operation is not implemented assert intrange().__gt__(floatrange()) is NotImplemented assert intrange().__ge__(floatrange()) is NotImplemented
def test_add(): rset = intrangeset([intrange(1, 15)]) rset.add(intrange(5, 15)) assert list(rset) == [intrange(1, 15)] with pytest.raises(TypeError): rset.add(floatrange(1.0))
def test_replace(): span = floatrange(1.0, 10.0) assert span.lower_inc assert not span.upper_inc unbounded_span = span.replace(None) assert unbounded_span.lower_inf assert not unbounded_span.lower_inc assert not unbounded_span.upper_inf assert not unbounded_span.upper_inc # It's a bit confusing that the replace doesn't remember that the range # used to be lower_inc. However, we don't have a way of telling that the # value has not been user specified rebounded_span = unbounded_span.replace(lower=1.0) assert not rebounded_span.lower_inc
def test_bug14_pickle_not_working_for_rangesets(): """ `Bug #14 <https://github.com/runfalk/spans/issues/14`_ """ # If __getstate__ returns a falsy value __setstate__ will not be called # when loading the value again, which is why this bug occured range_set = floatrangeset([]) pickled = pickle.dumps(range_set, protocol=1) pickle.loads(pickled) assert range_set == pickle.loads(pickled) # We need to ensure that code pickled using protocol 1 by spans versions # before 1.1.0 still loads old_data = ( b"ccopy_reg\n_reconstructor\nq\x00(cspans.settypes\nfloatrangeset\n" b"q\x01c__builtin__\nobject\nq\x02Ntq\x03Rq\x04]q\x05h\x00(cspans." b"types\nfloatrange\nq\x06h\x02Ntq\x07Rq\x08}q\tX\x06\x00\x00\x00_" b"rangeq\nh\x00(cspans.types\n_internal_range\nq\x0bc__builtin__\n" b"tuple\nq\x0c(G?\xf0\x00\x00\x00\x00\x00\x00NI01\nI00\nI00\ntq\rtq" b"\x0eRq\x0fsbab.") assert pickle.loads(old_data) == floatrangeset([floatrange(1.0)])
def test_remove(): rset = intrangeset([intrange(upper=1), intrange(5)]) rset.remove(intrange(10, 15)) assert rset == intrangeset([intrange(upper=1), intrange(5, 10), intrange(15)]) # Test deletion of empty set temp = rset.copy() temp.remove(intrange.empty()) assert rset == temp # Test total deletion rset.remove(intrange()) assert rset == intrangeset([]) # Test deletion on empty set temp = intrangeset([]) temp.remove(intrange(1, 5)) assert temp == intrangeset([]) with pytest.raises(TypeError): rset.remove(floatrange(1.0))
def test_remove(): rset = intrangeset([intrange(upper=1), intrange(5)]) rset.remove(intrange(10, 15)) assert rset == intrangeset( [intrange(upper=1), intrange(5, 10), intrange(15)]) # Test deletion of empty set temp = rset.copy() temp.remove(intrange.empty()) assert rset == temp # Test total deletion rset.remove(intrange()) assert rset == intrangeset([]) # Test deletion on empty set temp = intrangeset([]) temp.remove(intrange(1, 5)) assert temp == intrangeset([]) with pytest.raises(TypeError): rset.remove(floatrange(1.0))
def test_type_check(lower, upper): with pytest.raises(TypeError): floatrange(lower, upper)
def test_endswith(): # Special case that discrete ranges can't cover assert floatrange(upper=5.0, upper_inc=True).endswith(5.0)
def test_less_than(): # Special case that discrete ranges can't cover assert floatrange(1.0) < floatrange(1.0, lower_inc=False) assert not floatrange(1.0, lower_inc=False) < floatrange(1.0)
def test_invalid_bounds(lower, upper): with pytest.raises(ValueError): floatrange(lower, upper)
@pytest.mark.parametrize("lower, upper", [ (10.0, 5.0), ]) def test_invalid_bounds(lower, upper): with pytest.raises(ValueError): floatrange(lower, upper) def test_less_than(): # Special case that discrete ranges can't cover assert floatrange(1.0) < floatrange(1.0, lower_inc=False) assert not floatrange(1.0, lower_inc=False) < floatrange(1.0) @pytest.mark.parametrize("span, value", [ (floatrange(1.0, 5.0), 1.0), (floatrange(1.0, 5.0), 3.0), (floatrange(1.0, 5.0, upper_inc=True), 5.0), (floatrange(1.0, 5.0, lower_inc=False, upper_inc=True), 5.0), ]) def test_contains(span, value): assert span.contains(value) @pytest.mark.parametrize("span, value", [ (floatrange(1.0, 5.0, lower_inc=False), 1.0), (floatrange(1.0, 5.0), 5.0), ]) def test_not_contains(span, value): assert not span.contains(value)
def test_equality(): assert intrange(1, 5) == intrange(1, 5) assert intrange.empty() == intrange.empty() assert intrange(1, 5) != intrange(1, 5, upper_inc=True) assert floatrange() == floatrange() assert not intrange() == None
def test_right_of_type_check(): with pytest.raises(TypeError): floatrange().right_of(None) assert floatrange().__rshift__(None) is NotImplemented
range = intrange() assert range == range.offset(10) assert intrange(1).offset(9) == intrange(10) assert intrange(upper=1).offset(9) == intrange(upper=10) def test_equality(): assert intrange(1, 5) == intrange(1, 5) assert intrange.empty() == intrange.empty() assert intrange(1, 5) != intrange(1, 5, upper_inc=True) assert not intrange() == None @pytest.mark.parametrize("a, b", [ (floatrange(1.0, 5.0), floatrange(2.0, 5.0)), (floatrange(1.0, 4.0), floatrange(1.0, 5.0)), (floatrange(1.0, 5.0), floatrange(1.0, 5.0, upper_inc=True)), (floatrange(1.0, 5.0), floatrange(1.0)), (floatrange(upper=5.0), floatrange(1.0, 5.0)), ]) def test_less_than(a, b): assert a < b assert not b < a @pytest.mark.parametrize("a, b", [ (floatrange(1.0, 5.0), floatrange(1.0, 5.0)), (floatrange(1.0, 4.0), floatrange(1.0, 5.0)), ]) def test_less_equal(a, b):