def test_empty():
    assert i.open(1, 1).empty()
    assert i.open(3, 3).empty()
    assert i.openclosed(3, 3).empty()
    assert i.closedopen(3, 3).empty()
    assert not i.open(3, 4).empty()
    assert not i.openclosed(3, 4).empty()

def test_overlaps_open():
    one = i.open(1, 5)
    two = i.open(3, 10)
    assert one.overlaps(two)
    assert two.overlaps(one)
    assert one.overlaps(one)
    assert two.overlaps(two)

def test_overlaps_corner_case_open():
    one = i.open(1, 5)
    two = i.open(5, 10)
    assert not one.overlaps(two)
    assert not two.overlaps(one)
    assert one.overlaps(one)
    assert two.overlaps(two)

def test_overlaps_false():
    one = i.open(1, 5)
    two = i.open(7, 12)
    assert not one.overlaps(two)
    assert not two.overlaps(one)
    assert one.overlaps(one)
    assert two.overlaps(two)

def test_contains_self_open():
    small = i.open(1, 5)
    medium = i.open(3, 10)
    assert small in small
    assert small not in medium
    assert medium not in small
    assert medium in medium

def test_subtract_overlapping():
    left = IntervalSet((i.open(1, 4), i.open(5, 10)))
    right = IntervalSet((i.open(0, 2), i.open(6, 8)))
    expected = IntervalSet((
        i.closedopen(2, 4),
        i.openclosed(5, 6),
        i.closedopen(8, 10),
    ))
    assert left - right == expected

def test_complement():
    one = i.open(3, 6)
    two = i.open(7, 10)
    intervals = IntervalSet([one, two])
    complement = intervals.complement()
    (lower, middle, upper) = sorted(complement)  # an IntervalSet is not sorted

    assert lower == i.openclosed(i.NEGATIVE_INFINITY, 3)
    assert middle == i.closed(6, 7)
    assert upper == i.closedopen(10, i.INFINITY)

def test_values_in():
    one = i.open(1, 5)
    two = i.closed(7, 10)
    ivset = IntervalSet((i.open(1, 5), i.closed(7, 10)))
    assert 1 not in ivset
    assert 1.00000001 in ivset
    assert 3 in ivset
    assert 7 in ivset
    assert 8 in ivset
    assert 10.0001 not in ivset
    assert one in ivset
    assert two in ivset

def test_non_equality():
    small, medium = get_intervals()[:2]
    assert small != medium
    assert small != i.openclosed(1,5)
    assert small != i.closedopen(1,5)
    assert small != i.closed(1,5)
    assert small != i.Interval(i.Interval.OPEN, 1, 7, i.Interval.OPEN)
    assert small != i.open(100, 288)

def test_open_interval_construction_using_helper():
    expected_lower = i.Interval.OPEN
    expectedlower_value = 10
    expected_upper_value = 100
    expected_upper = i.Interval.OPEN
    result = i.open(10, 100)
    assert result.lower == expected_lower
    assert result.lower_value == expectedlower_value
    assert result.upper_value == expected_upper_value
    assert result.upper == expected_upper

def test_overlaps_empty():
    assert not i.open(0, 0).overlaps(i.closed(1, 20))
    assert not i.open(1, 1).overlaps(i.closed(1, 20))
    assert not i.open(2, 2).overlaps(i.closed(1, 20))
    assert not i.closed(1, 20).overlaps(i.open(0, 0))
    assert not i.closed(1, 20).overlaps(i.open(1, 1))
    assert not i.closed(1, 20).overlaps(i.open(2, 2))

def test_overlaps_does_not_change_intervals():
    one = i.open(3, 6)
    two = i.open(1, 4)
    assert one.overlaps(two)
    assert one == i.open(3, 6)
    assert two == i.open(1, 4)
    assert two.overlaps(one)
    assert one == i.open(3, 6)
    assert two == i.open(1, 4)

def test_equality_of_not_equal():
    one = IntervalSet([i.open(1, 10)])
    two = IntervalSet([i.closed(1, 10)])
    assert one != two

def test_equality_of_two_equal_instances():
    one = IntervalSet([i.open(1, 10)])
    two = IntervalSet([i.open(1, 10)])
    assert one == two

def test_length_of_unioned():
    first = IntervalSet((i.open(1, 5), i.closed(7, 10)))
    second = IntervalSet((i.open(8, 21), i.closed(22,23)))
    # This is of length 3 as 2 of the intervals overlap and therefore join together
    assert len(first.union(second)) == 3

def test_len_works_as_expected():
    assert len(IntervalSet((i.open(1, 5), i.closed(7, 10)))) == 2

def test_union_non_overlapping():
    one = i.open(3, 6)
    two = i.open(8, 10)
    expected = IntervalSet([one, two])
    assert one.union(two) == expected
    assert two.union(one) == expected

def test_union_overlapping():
    one = i.open(3, 6)
    two = i.open(4, 10)
    expected = i.open(3, 10)
    assert one.union(two) == expected
    assert two.union(one) == expected

def test_intersection_via_overloaded_and():
    one = i.open(3, 6)
    two = i.open(4, 10)
    expected = i.open(4, 6)
    assert one & two == expected
    assert two & one == expected

def test_union_of_disjoint():
    first = IntervalSet((i.open(1, 5), i.closed(7, 10)))
    second = IntervalSet((i.open(12, 21), i.closed(22,23)))
    expected = IntervalSet((i.open(1, 5), i.closed(7, 10), i.open(12, 21), i.closed(22, 23)))
    result = first.union(second)
    assert result == expected