def test_auto_incremented_register_inequality(m, n, delta, gamma): assume((m != n) or (delta != gamma)) Register._names_and_widths.clear() a = Register(m, len(m)) b = Register(n, len(n)) assert AutoIncrementedRegister(a, delta) != AutoIncrementedRegister( b, gamma)
def test_auto_incremented_register_increments_out_of_range_raise_value_error( m, delta): assume(delta not in {-2, -1, +1, +2}) Register._names_and_widths.clear() r = Register(m, len(m)) with raises(ValueError): AutoIncrementedRegister(r, delta)
def test_auto_incremented_register_repr(name, delta): a = Register(name, len(name)) r = repr(AutoIncrementedRegister(a, delta)) assert r.startswith('AutoIncrementedRegister') assert name in r assert str(delta) in r assert check_balanced(r)
def test_register_pre_decrement_with_illegal_delta_raises_value_error( m, delta): assume(delta not in {-2, -1, +1, +2}) Register._names_and_widths.clear() r = Register(m, len(m)) with raises(ValueError): delta - r
def test_register_unspecified_width_raises_value_error(name): with raises(ValueError): Register(name)
def test_illegal_register_width(width): with raises(ValueError): Register('BAR', width)
def test_register_width_default(): Register._names_and_widths.clear() Register('FOO', 2) assert Register('FOO').width == 2
def test_register_post_increment(m, delta): Register._names_and_widths.clear() r = Register(m, len(m)) assert r+delta == AutoIncrementedRegister(r, delta)
def test_register_hash_equality(m): Register._names_and_widths.clear() assert hash(Register(m, len(m))) == hash(Register(m, len(m)))
def test_register_inequality(m, n): Register._names_and_widths.clear() assume(m != n) assert Register(m, len(m)) != Register(n, len(n))
def test_auto_incremented_register_inequality_different_types(m, delta): Register._names_and_widths.clear() a = Register(m, len(m)) assert AutoIncrementedRegister(a, delta) != object()
def test_register_illegal_initial_character_raises_value_error(m): with raises(ValueError): Register(m, len(m))
def test_register_pre_decrement_with_illegal_delta_raises_type_error(m): Register._names_and_widths.clear() r = Register(m, len(m)) with raises(TypeError): object()-r
def test_empty_register_raises_value_error(): with raises(ValueError): Register('', 1)
def test_register_repr(name): r = repr(Register(name, len(name))) assert r.startswith('Register') assert name in r assert str(len(name)) in r assert check_balanced(r)
def test_register_equality(m): Register._names_and_widths.clear() assert Register(m, len(m)) == Register(m, len(m))
def test_auto_incremented_register_hash_equality(m, delta): Register._names_and_widths.clear() a = Register(m, len(m)) b = Register(m, len(m)) assert hash(AutoIncrementedRegister(a, delta)) == hash(AutoIncrementedRegister(b, delta))
def test_register_inequality_different_types(m): Register._names_and_widths.clear() assert Register(m, len(m)) != object()
def test_register_name(name): assume(name not in {r.name for r in REGISTERS}) assert str(Register(name, len(name))) == name
def test_register_less_than_different_types(m): Register._names_and_widths.clear() with raises(TypeError): assert Register(m, len(m)) < object()
def test_inconsistent_width_raises_value_error(name, width_a, width_b): Register._names_and_widths.clear() assume(width_a != width_b) Register(name, width_a) with raises(ValueError): Register(name, width_b)
def test_register_pre_decrement(m, delta): Register._names_and_widths.clear() r = Register(m, len(m)) assert delta-r == AutoIncrementedRegister(r, -delta)
def test_register_width(): Register._names_and_widths.clear() assert Register('FOO', 2).width == 2