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_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):
