tests/test_setattr.py - external/github.com/python-attrs/attrs - Git at Google

 # SPDX-License-Identifier: MIT


 import pickle

 import pytest

 import attr

 from attr import setters
 from attr.exceptions import FrozenAttributeError
 from attr.validators import instance_of, matches_re


 @attr.s(frozen=True)
 class Frozen:
     x = attr.ib()


 @attr.s
 class WithOnSetAttrHook:
     x = attr.ib(on_setattr=lambda *args: None)


 class TestSetAttr:
     def test_change(self):
         """
         The return value of a hook overwrites the value. But they are not run
         on __init__.
         """

         def hook(*a, **kw):
             return "hooked!"

         @attr.s
         class Hooked:
             x = attr.ib(on_setattr=hook)
             y = attr.ib()

         h = Hooked("x", "y")

         assert "x" == h.x
         assert "y" == h.y

         h.x = "xxx"
         h.y = "yyy"

         assert "yyy" == h.y
         assert "hooked!" == h.x

     def test_change_with_generator_hook(self):
         """
         The value yielded by a generator hook overwrites the value.
         """

         def hook(instance, attrib, value):
             yield "yielded!"

         @attr.s
         class Hooked:
             x = attr.ib(on_setattr=hook)

         h = Hooked("x")

         assert "x" == h.x

         h.x = "xxx"

         assert "yielded!" == h.x

     def test_generator_hook_executes_after_yielding(self):
         """
         Generator post-yield code runs after the value is set on the instance.
         """
         calls = []

         def hook(instance, attrib, value):
             calls.append(("pre", instance.x))
             yield value
             calls.append(("post", instance.x))

         @attr.s
         class Hooked:
             x = attr.ib(on_setattr=hook)

         h = Hooked("x")

         assert "x" == h.x
         assert [] == calls

         h.x = "xxx"

         assert [("pre", "x"), ("post", "xxx")] == calls
         assert "xxx" == h.x

     def test_frozen_attribute(self):
         """
         Frozen attributes raise FrozenAttributeError, others are not affected.
         """

         @attr.s
         class PartiallyFrozen:
             x = attr.ib(on_setattr=setters.frozen)
             y = attr.ib()

         pf = PartiallyFrozen("x", "y")

         pf.y = "yyy"

         assert "yyy" == pf.y

         with pytest.raises(FrozenAttributeError):
             pf.x = "xxx"

         assert "x" == pf.x

     @pytest.mark.parametrize(
         "on_setattr",
         [setters.validate, [setters.validate], setters.pipe(setters.validate)],
     )
     def test_validator(self, on_setattr):
         """
         Validators are run and they don't alter the value.
         """

         @attr.s(on_setattr=on_setattr)
         class ValidatedAttribute:
             x = attr.ib()
             y = attr.ib(validator=[instance_of(str), matches_re("foo.*qux")])

         va = ValidatedAttribute(42, "foobarqux")

         with pytest.raises(TypeError) as ei:
             va.y = 42

         assert "foobarqux" == va.y

         assert ei.value.args[0].startswith("'y' must be <")

         with pytest.raises(ValueError) as ei:
             va.y = "quxbarfoo"

         assert ei.value.args[0].startswith("'y' must match regex '")

         assert "foobarqux" == va.y

         va.y = "foobazqux"

         assert "foobazqux" == va.y

     def test_pipe(self):
         """
         Multiple hooks are possible, in that case the last return value is
         used. They can be supplied using the pipe functions or by passing a
         list to on_setattr.
         """
         taken = None

         def takes_all(val, instance, attrib):
             nonlocal taken
             taken = val, instance, attrib

             return val

         s = [setters.convert, lambda _, __, nv: nv + 1]

         @attr.s
         class Piped:
             x1 = attr.ib(
                 converter=[
                     attr.Converter(
                         takes_all, takes_field=True, takes_self=True
                     ),
                     int,
                 ],
                 on_setattr=setters.pipe(*s),
             )
             x2 = attr.ib(converter=int, on_setattr=s)

         p = Piped("41", "22")

         assert ("41", p) == taken[:-1]
         assert "x1" == taken[-1].name

         assert 41 == p.x1
         assert 22 == p.x2

         p.x1 = "41"
         p.x2 = "22"

         assert 42 == p.x1
         assert 23 == p.x2

     def test_generator_hook_not_called_in_init(self):
         """
         Generator hooks are not invoked during __init__, same as regular hooks.
         """

         def hook(instance, attrib, value):
             yield "hooked"

         @attr.s
         class Hooked:
             x = attr.ib(on_setattr=hook)

         h = Hooked("x")

         assert "x" == h.x

         h.x = "xxx"

         assert "hooked" == h.x

     def test_generator_hook_with_define(self):
         """
         Generator hooks work with attrs.define.
         """

         def hook(instance, attrib, value):
             yield value.upper()

         @attr.define
         class C:
             x: str = attr.field(on_setattr=hook)

         c = C("hello")

         assert "hello" == c.x

         c.x = "world"

         assert "WORLD" == c.x

     def test_generator_hook_class_level(self):
         """
         Generator hooks work as class-level on_setattr.
         """

         call_count = 0

         def hook(instance, attrib, value):
             nonlocal call_count
             call_count += 1
             yield value

         @attr.s(on_setattr=hook)
         class C:
             x = attr.ib()
             y = attr.ib()

         c = C(1, 2)

         assert 1 == c.x
         assert 2 == c.y

         c.x = 10
         assert 1 == call_count

         c.y = 20
         assert 2 == call_count

     def test_generator_pre_yield_exception(self):
         """
         If a generator raises before yielding, the value is not set.
         """

         def hook(instance, attrib, value):
             raise ValueError("bad value")
             yield

         @attr.s
         class C:
             x = attr.ib(on_setattr=hook)

         c = C("original")

         with pytest.raises(ValueError, match="bad value"):
             c.x = "new"

         assert "original" == c.x

     def test_generator_post_yield_exception(self):
         """
         If a generator raises after yielding, the value is already set and
         the exception propagates.
         """

         def hook(instance, attrib, value):
             yield value
             raise RuntimeError("post-yield failure")

         @attr.s
         class C:
             x = attr.ib(on_setattr=hook)

         c = C("original")

         with pytest.raises(RuntimeError, match="post-yield failure"):
             c.x = "new"

         assert "new" == c.x

     def test_generator_yields_multiple_times(self):
         """
         Yielding more than once raises an error and closes the generator.
         """
         cleaned_up = False

         def hook(instance, attrib, value):
             nonlocal cleaned_up

             try:
                 yield "first"
                 yield "second"
             finally:
                 cleaned_up = True

         @attr.s
         class C:
             x = attr.ib(on_setattr=hook)

         c = C("old")

         with pytest.raises(
             RuntimeError,
             match="Generator on_setattr hook yielded more than once",
         ):
             c.x = "new"

         assert "first" == c.x
         assert cleaned_up is True

     def test_make_class(self):
         """
         on_setattr of make_class gets forwarded.
         """
         C = attr.make_class("C", {"x": attr.ib()}, on_setattr=setters.frozen)

         c = C(1)

         with pytest.raises(FrozenAttributeError):
             c.x = 2

     def test_no_validator_no_converter(self):
         """
         validate and convert tolerate missing validators and converters.
         """

         @attr.s(on_setattr=[setters.convert, setters.validate])
         class C:
             x = attr.ib()

         c = C(1)

         c.x = 2

         assert 2 == c.x

     def test_validate_respects_run_validators_config(self):
         """
         If run validators is off, validate doesn't run them.
         """

         @attr.s(on_setattr=setters.validate)
         class C:
             x = attr.ib(validator=attr.validators.instance_of(int))

         c = C(1)

         attr.set_run_validators(False)

         c.x = "1"

         assert "1" == c.x

         attr.set_run_validators(True)

         with pytest.raises(TypeError) as ei:
             c.x = "1"

         assert ei.value.args[0].startswith("'x' must be <")

     def test_frozen_on_setattr_class_is_caught(self):
         """
         @attr.s(on_setattr=X, frozen=True) raises an ValueError.
         """
         with pytest.raises(ValueError) as ei:

             @attr.s(frozen=True, on_setattr=setters.validate)
             class C:
                 x = attr.ib()

         assert "Frozen classes can't use on_setattr." == ei.value.args[0]

     def test_frozen_on_setattr_attribute_is_caught(self):
         """
         attr.ib(on_setattr=X) on a frozen class raises an ValueError.
         """

         with pytest.raises(ValueError) as ei:

             @attr.s(frozen=True)
             class C:
                 x = attr.ib(on_setattr=setters.validate)

         assert "Frozen classes can't use on_setattr." == ei.value.args[0]

     @pytest.mark.parametrize("nop", [None, setters.NO_OP])
     def test_frozen_on_setattr_nops(self, nop):
         """
         on_setattr on frozen classes can be used for None and NO_OP.
         """

         @attr.s(frozen=True)
         class C:
             x = attr.ib(on_setattr=nop)

     def test_setattr_reset_if_no_custom_setattr(self, slots):
         """
         If a class with an active setattr is subclassed and no new setattr
         is generated, the __setattr__ is set to object.__setattr__.

         We do the double test because of Python 2.
         """

         def boom(*args):
             pytest.fail("Must not be called.")

         @attr.s
         class Hooked:
             x = attr.ib(on_setattr=boom)

         @attr.s(slots=slots)
         class NoHook(WithOnSetAttrHook):
             x = attr.ib()

         assert NoHook.__setattr__ == object.__setattr__
         assert 1 == NoHook(1).x
         assert Hooked.__attrs_own_setattr__
         assert not NoHook.__attrs_own_setattr__
         assert WithOnSetAttrHook.__attrs_own_setattr__

     def test_setattr_inherited_do_not_reset(self, slots):
         """
         If we inherit a __setattr__ that has been written by the user, we must
         not reset it unless necessary.
         """

         class A:
             """
             Not an attrs class on purpose to prevent accidental resets that
             would render the asserts meaningless.
             """

             def __setattr__(self, *args):
                 pass

         @attr.s(slots=slots)
         class B(A):
             pass

         assert B.__setattr__ == A.__setattr__

         @attr.s(slots=slots)
         class C(B):
             pass

         assert C.__setattr__ == A.__setattr__

     def test_pickling_retains_attrs_own(self, slots):
         """
         Pickling/Unpickling does not lose ownership information about
         __setattr__.
         """
         i = WithOnSetAttrHook(1)

         assert True is i.__attrs_own_setattr__

         i2 = pickle.loads(pickle.dumps(i))

         assert True is i2.__attrs_own_setattr__

         WOSAH = pickle.loads(pickle.dumps(WithOnSetAttrHook))

         assert True is WOSAH.__attrs_own_setattr__

     def test_slotted_class_can_have_custom_setattr(self):
         """
         A slotted class can define a custom setattr and it doesn't get
         overwritten.

         Regression test for #680.
         """

         @attr.s(slots=True)
         class A:
             def __setattr__(self, key, value):
                 raise SystemError

         with pytest.raises(SystemError):
             A().x = 1

     @pytest.mark.xfail(raises=attr.exceptions.FrozenAttributeError)
     def test_slotted_confused(self):
         """
         If we have a in-between non-attrs class, setattr reset detection
         should still work, but currently doesn't.

         It works with dict classes because we can look the finished class and
         patch it.  With slotted classes we have to deduce it ourselves.
         """

         @attr.s(slots=True)
         class A:
             x = attr.ib(on_setattr=setters.frozen)

         class B(A):
             pass

         @attr.s(slots=True)
         class C(B):
             x = attr.ib()

         C(1).x = 2

     def test_setattr_auto_detect_if_no_custom_setattr(self, slots):
         """
         It's possible to remove the on_setattr hook from an attribute and
         therefore write a custom __setattr__.
         """
         assert 1 == WithOnSetAttrHook(1).x

         @attr.s(auto_detect=True, slots=slots)
         class RemoveNeedForOurSetAttr(WithOnSetAttrHook):
             x = attr.ib()

             def __setattr__(self, name, val):
                 object.__setattr__(self, name, val * 2)

         i = RemoveNeedForOurSetAttr(1)

         assert not RemoveNeedForOurSetAttr.__attrs_own_setattr__
         assert 2 == i.x

     def test_setattr_restore_respects_auto_detect(self, slots):
         """
         If __setattr__ should be restored but the user supplied its own and
         set auto_detect, leave is alone.
         """

         @attr.s(auto_detect=True, slots=slots)
         class CustomSetAttr:
             def __setattr__(self, _, __):
                 pass

         assert CustomSetAttr.__setattr__ != object.__setattr__

     def test_setattr_auto_detect_frozen(self, slots):
         """
         frozen=True together with a detected custom __setattr__ are rejected.
         """
         with pytest.raises(
             ValueError, match="Can't freeze a class with a custom __setattr__"
         ):

             @attr.s(auto_detect=True, slots=slots, frozen=True)
             class CustomSetAttr(Frozen):
                 def __setattr__(self, _, __):
                     pass

     def test_setattr_auto_detect_on_setattr(self, slots):
         """
         on_setattr attributes together with a detected custom __setattr__ are
         rejected.
         """
         with pytest.raises(
             ValueError,
             match="Can't combine custom __setattr__ with on_setattr hooks",
         ):

             @attr.s(auto_detect=True, slots=slots)
             class HookAndCustomSetAttr:
                 x = attr.ib(on_setattr=lambda *args: None)

                 def __setattr__(self, _, __):
                     pass

     @pytest.mark.parametrize("a_slots", [True, False])
     @pytest.mark.parametrize("b_slots", [True, False])
     @pytest.mark.parametrize("c_slots", [True, False])
     def test_setattr_inherited_do_not_reset_intermediate(
         self, a_slots, b_slots, c_slots
     ):
         """
         A user-provided intermediate __setattr__ is not reset to
         object.__setattr__.

         This only can work with auto_detect activated, such that attrs can know
         that there is a user-provided __setattr__.
         """

         @attr.s(slots=a_slots)
         class A:
             x = attr.ib(on_setattr=setters.frozen)

         @attr.s(slots=b_slots, auto_detect=True)
         class B(A):
             x = attr.ib(on_setattr=setters.NO_OP)

             def __setattr__(self, key, value):
                 raise SystemError

         @attr.s(slots=c_slots)
         class C(B):
             pass

         assert getattr(A, "__attrs_own_setattr__", False) is True
         assert getattr(B, "__attrs_own_setattr__", False) is False
         assert getattr(C, "__attrs_own_setattr__", False) is False

         with pytest.raises(SystemError):
             C(1).x = 3

     def test_docstring(self):
         """
         Generated __setattr__ has a useful docstring.
         """
         assert (
             "Method generated by attrs for class WithOnSetAttrHook."
             == WithOnSetAttrHook.__setattr__.__doc__
         )

     def test_setattr_converter_piped(self):
         """
         If a converter is used, it is piped through the on_setattr hooks.

         Regression test for https://github.com/python-attrs/attrs/issues/1327
         """

         @attr.define  # converter on setattr is implied in NG
         class C:
             x = attr.field(converter=[int])

         c = C("1")
         c.x = "2"

         assert 2 == c.x
	# SPDX-License-Identifier: MIT


	import pickle

	import pytest

	import attr

	from attr import setters
	from attr.exceptions import FrozenAttributeError
	from attr.validators import instance_of, matches_re


	@attr.s(frozen=True)
	class Frozen:
	x = attr.ib()


	@attr.s
	class WithOnSetAttrHook:
	x = attr.ib(on_setattr=lambda *args: None)


	class TestSetAttr:
	def test_change(self):
	"""
	The return value of a hook overwrites the value. But they are not run
	on __init__.
	"""

	def hook(a, *kw):
	return "hooked!"

	@attr.s
	class Hooked:
	x = attr.ib(on_setattr=hook)
	y = attr.ib()

	h = Hooked("x", "y")

	assert "x" == h.x
	assert "y" == h.y

	h.x = "xxx"
	h.y = "yyy"

	assert "yyy" == h.y
	assert "hooked!" == h.x

	def test_change_with_generator_hook(self):
	"""
	The value yielded by a generator hook overwrites the value.
	"""

	def hook(instance, attrib, value):
	yield "yielded!"

	@attr.s
	class Hooked:
	x = attr.ib(on_setattr=hook)

	h = Hooked("x")

	assert "x" == h.x

	h.x = "xxx"

	assert "yielded!" == h.x

	def test_generator_hook_executes_after_yielding(self):
	"""
	Generator post-yield code runs after the value is set on the instance.
	"""
	calls = []

	def hook(instance, attrib, value):
	calls.append(("pre", instance.x))
	yield value
	calls.append(("post", instance.x))

	@attr.s
	class Hooked:
	x = attr.ib(on_setattr=hook)

	h = Hooked("x")

	assert "x" == h.x
	assert [] == calls

	h.x = "xxx"

	assert [("pre", "x"), ("post", "xxx")] == calls
	assert "xxx" == h.x

	def test_frozen_attribute(self):
	"""
	Frozen attributes raise FrozenAttributeError, others are not affected.
	"""

	@attr.s
	class PartiallyFrozen:
	x = attr.ib(on_setattr=setters.frozen)
	y = attr.ib()

	pf = PartiallyFrozen("x", "y")

	pf.y = "yyy"

	assert "yyy" == pf.y

	with pytest.raises(FrozenAttributeError):
	pf.x = "xxx"

	assert "x" == pf.x

	@pytest.mark.parametrize(
	"on_setattr",
	[setters.validate, [setters.validate], setters.pipe(setters.validate)],
	)
	def test_validator(self, on_setattr):
	"""
	Validators are run and they don't alter the value.
	"""

	@attr.s(on_setattr=on_setattr)
	class ValidatedAttribute:
	x = attr.ib()
	y = attr.ib(validator=[instance_of(str), matches_re("foo.*qux")])

	va = ValidatedAttribute(42, "foobarqux")

	with pytest.raises(TypeError) as ei:
	va.y = 42

	assert "foobarqux" == va.y

	assert ei.value.args[0].startswith("'y' must be <")

	with pytest.raises(ValueError) as ei:
	va.y = "quxbarfoo"

	assert ei.value.args[0].startswith("'y' must match regex '")

	assert "foobarqux" == va.y

	va.y = "foobazqux"

	assert "foobazqux" == va.y

	def test_pipe(self):
	"""
	Multiple hooks are possible, in that case the last return value is
	used. They can be supplied using the pipe functions or by passing a
	list to on_setattr.
	"""
	taken = None

	def takes_all(val, instance, attrib):
	nonlocal taken
	taken = val, instance, attrib

	return val

	s = [setters.convert, lambda _, __, nv: nv + 1]

	@attr.s
	class Piped:
	x1 = attr.ib(
	converter=[
	attr.Converter(
	takes_all, takes_field=True, takes_self=True
	),
	int,
	],
	on_setattr=setters.pipe(*s),
	)
	x2 = attr.ib(converter=int, on_setattr=s)

	p = Piped("41", "22")

	assert ("41", p) == taken[:-1]
	assert "x1" == taken[-1].name

	assert 41 == p.x1
	assert 22 == p.x2

	p.x1 = "41"
	p.x2 = "22"

	assert 42 == p.x1
	assert 23 == p.x2

	def test_generator_hook_not_called_in_init(self):
	"""
	Generator hooks are not invoked during __init__, same as regular hooks.
	"""

	def hook(instance, attrib, value):
	yield "hooked"

	@attr.s
	class Hooked:
	x = attr.ib(on_setattr=hook)

	h = Hooked("x")

	assert "x" == h.x

	h.x = "xxx"

	assert "hooked" == h.x

	def test_generator_hook_with_define(self):
	"""
	Generator hooks work with attrs.define.
	"""

	def hook(instance, attrib, value):
	yield value.upper()

	@attr.define
	class C:
	x: str = attr.field(on_setattr=hook)

	c = C("hello")

	assert "hello" == c.x

	c.x = "world"

	assert "WORLD" == c.x

	def test_generator_hook_class_level(self):
	"""
	Generator hooks work as class-level on_setattr.
	"""

	call_count = 0

	def hook(instance, attrib, value):
	nonlocal call_count
	call_count += 1
	yield value

	@attr.s(on_setattr=hook)
	class C:
	x = attr.ib()
	y = attr.ib()

	c = C(1, 2)

	assert 1 == c.x
	assert 2 == c.y

	c.x = 10
	assert 1 == call_count

	c.y = 20
	assert 2 == call_count

	def test_generator_pre_yield_exception(self):
	"""
	If a generator raises before yielding, the value is not set.
	"""

	def hook(instance, attrib, value):
	raise ValueError("bad value")
	yield

	@attr.s
	class C:
	x = attr.ib(on_setattr=hook)

	c = C("original")

	with pytest.raises(ValueError, match="bad value"):
	c.x = "new"

	assert "original" == c.x

	def test_generator_post_yield_exception(self):
	"""
	If a generator raises after yielding, the value is already set and
	the exception propagates.
	"""

	def hook(instance, attrib, value):
	yield value
	raise RuntimeError("post-yield failure")

	@attr.s
	class C:
	x = attr.ib(on_setattr=hook)

	c = C("original")

	with pytest.raises(RuntimeError, match="post-yield failure"):
	c.x = "new"

	assert "new" == c.x

	def test_generator_yields_multiple_times(self):
	"""
	Yielding more than once raises an error and closes the generator.
	"""
	cleaned_up = False

	def hook(instance, attrib, value):
	nonlocal cleaned_up

	try:
	yield "first"
	yield "second"
	finally:
	cleaned_up = True

	@attr.s
	class C:
	x = attr.ib(on_setattr=hook)

	c = C("old")

	with pytest.raises(
	RuntimeError,
	match="Generator on_setattr hook yielded more than once",
	):
	c.x = "new"

	assert "first" == c.x
	assert cleaned_up is True

	def test_make_class(self):
	"""
	on_setattr of make_class gets forwarded.
	"""
	C = attr.make_class("C", {"x": attr.ib()}, on_setattr=setters.frozen)

	c = C(1)

	with pytest.raises(FrozenAttributeError):
	c.x = 2

	def test_no_validator_no_converter(self):
	"""
	validate and convert tolerate missing validators and converters.
	"""

	@attr.s(on_setattr=[setters.convert, setters.validate])
	class C:
	x = attr.ib()

	c = C(1)

	c.x = 2

	assert 2 == c.x

	def test_validate_respects_run_validators_config(self):
	"""
	If run validators is off, validate doesn't run them.
	"""

	@attr.s(on_setattr=setters.validate)
	class C:
	x = attr.ib(validator=attr.validators.instance_of(int))

	c = C(1)

	attr.set_run_validators(False)

	c.x = "1"

	assert "1" == c.x

	attr.set_run_validators(True)

	with pytest.raises(TypeError) as ei:
	c.x = "1"

	assert ei.value.args[0].startswith("'x' must be <")

	def test_frozen_on_setattr_class_is_caught(self):
	"""
	@attr.s(on_setattr=X, frozen=True) raises an ValueError.
	"""
	with pytest.raises(ValueError) as ei:

	@attr.s(frozen=True, on_setattr=setters.validate)
	class C:
	x = attr.ib()

	assert "Frozen classes can't use on_setattr." == ei.value.args[0]

	def test_frozen_on_setattr_attribute_is_caught(self):
	"""
	attr.ib(on_setattr=X) on a frozen class raises an ValueError.
	"""

	with pytest.raises(ValueError) as ei:

	@attr.s(frozen=True)
	class C:
	x = attr.ib(on_setattr=setters.validate)

	assert "Frozen classes can't use on_setattr." == ei.value.args[0]

	@pytest.mark.parametrize("nop", [None, setters.NO_OP])
	def test_frozen_on_setattr_nops(self, nop):
	"""
	on_setattr on frozen classes can be used for None and NO_OP.
	"""

	@attr.s(frozen=True)
	class C:
	x = attr.ib(on_setattr=nop)

	def test_setattr_reset_if_no_custom_setattr(self, slots):
	"""
	If a class with an active setattr is subclassed and no new setattr
	is generated, the __setattr__ is set to object.__setattr__.

	We do the double test because of Python 2.
	"""

	def boom(*args):
	pytest.fail("Must not be called.")

	@attr.s
	class Hooked:
	x = attr.ib(on_setattr=boom)

	@attr.s(slots=slots)
	class NoHook(WithOnSetAttrHook):
	x = attr.ib()

	assert NoHook.__setattr__ == object.__setattr__
	assert 1 == NoHook(1).x
	assert Hooked.__attrs_own_setattr__
	assert not NoHook.__attrs_own_setattr__
	assert WithOnSetAttrHook.__attrs_own_setattr__

	def test_setattr_inherited_do_not_reset(self, slots):
	"""
	If we inherit a __setattr__ that has been written by the user, we must
	not reset it unless necessary.
	"""

	class A:
	"""
	Not an attrs class on purpose to prevent accidental resets that
	would render the asserts meaningless.
	"""

	def __setattr__(self, *args):
	pass

	@attr.s(slots=slots)
	class B(A):
	pass

	assert B.__setattr__ == A.__setattr__

	@attr.s(slots=slots)
	class C(B):
	pass

	assert C.__setattr__ == A.__setattr__

	def test_pickling_retains_attrs_own(self, slots):
	"""
	Pickling/Unpickling does not lose ownership information about
	__setattr__.
	"""
	i = WithOnSetAttrHook(1)

	assert True is i.__attrs_own_setattr__

	i2 = pickle.loads(pickle.dumps(i))

	assert True is i2.__attrs_own_setattr__

	WOSAH = pickle.loads(pickle.dumps(WithOnSetAttrHook))

	assert True is WOSAH.__attrs_own_setattr__

	def test_slotted_class_can_have_custom_setattr(self):
	"""
	A slotted class can define a custom setattr and it doesn't get
	overwritten.

	Regression test for #680.
	"""

	@attr.s(slots=True)
	class A:
	def __setattr__(self, key, value):
	raise SystemError

	with pytest.raises(SystemError):
	A().x = 1

	@pytest.mark.xfail(raises=attr.exceptions.FrozenAttributeError)
	def test_slotted_confused(self):
	"""
	If we have a in-between non-attrs class, setattr reset detection
	should still work, but currently doesn't.

	It works with dict classes because we can look the finished class and
	patch it. With slotted classes we have to deduce it ourselves.
	"""

	@attr.s(slots=True)
	class A:
	x = attr.ib(on_setattr=setters.frozen)

	class B(A):
	pass

	@attr.s(slots=True)
	class C(B):
	x = attr.ib()

	C(1).x = 2

	def test_setattr_auto_detect_if_no_custom_setattr(self, slots):
	"""
	It's possible to remove the on_setattr hook from an attribute and
	therefore write a custom __setattr__.
	"""
	assert 1 == WithOnSetAttrHook(1).x

	@attr.s(auto_detect=True, slots=slots)
	class RemoveNeedForOurSetAttr(WithOnSetAttrHook):
	x = attr.ib()

	def __setattr__(self, name, val):
	object.__setattr__(self, name, val * 2)

	i = RemoveNeedForOurSetAttr(1)

	assert not RemoveNeedForOurSetAttr.__attrs_own_setattr__
	assert 2 == i.x

	def test_setattr_restore_respects_auto_detect(self, slots):
	"""
	If __setattr__ should be restored but the user supplied its own and
	set auto_detect, leave is alone.
	"""

	@attr.s(auto_detect=True, slots=slots)
	class CustomSetAttr:
	def __setattr__(self, _, __):
	pass

	assert CustomSetAttr.__setattr__ != object.__setattr__

	def test_setattr_auto_detect_frozen(self, slots):
	"""
	frozen=True together with a detected custom __setattr__ are rejected.
	"""
	with pytest.raises(
	ValueError, match="Can't freeze a class with a custom __setattr__"
	):

	@attr.s(auto_detect=True, slots=slots, frozen=True)
	class CustomSetAttr(Frozen):
	def __setattr__(self, _, __):
	pass

	def test_setattr_auto_detect_on_setattr(self, slots):
	"""
	on_setattr attributes together with a detected custom __setattr__ are
	rejected.
	"""
	with pytest.raises(
	ValueError,
	match="Can't combine custom __setattr__ with on_setattr hooks",
	):

	@attr.s(auto_detect=True, slots=slots)
	class HookAndCustomSetAttr:
	x = attr.ib(on_setattr=lambda *args: None)

	def __setattr__(self, _, __):
	pass

	@pytest.mark.parametrize("a_slots", [True, False])
	@pytest.mark.parametrize("b_slots", [True, False])
	@pytest.mark.parametrize("c_slots", [True, False])
	def test_setattr_inherited_do_not_reset_intermediate(
	self, a_slots, b_slots, c_slots
	):
	"""
	A user-provided intermediate __setattr__ is not reset to
	object.__setattr__.

	This only can work with auto_detect activated, such that attrs can know
	that there is a user-provided __setattr__.
	"""

	@attr.s(slots=a_slots)
	class A:
	x = attr.ib(on_setattr=setters.frozen)

	@attr.s(slots=b_slots, auto_detect=True)
	class B(A):
	x = attr.ib(on_setattr=setters.NO_OP)

	def __setattr__(self, key, value):
	raise SystemError

	@attr.s(slots=c_slots)
	class C(B):
	pass

	assert getattr(A, "__attrs_own_setattr__", False) is True
	assert getattr(B, "__attrs_own_setattr__", False) is False
	assert getattr(C, "__attrs_own_setattr__", False) is False

	with pytest.raises(SystemError):
	C(1).x = 3

	def test_docstring(self):
	"""
	Generated __setattr__ has a useful docstring.
	"""
	assert (
	"Method generated by attrs for class WithOnSetAttrHook."
	== WithOnSetAttrHook.__setattr__.__doc__
	)

	def test_setattr_converter_piped(self):
	"""
	If a converter is used, it is piped through the on_setattr hooks.

	Regression test for https://github.com/python-attrs/attrs/issues/1327
	"""

	@attr.define # converter on setattr is implied in NG
	class C:
	x = attr.field(converter=[int])

	c = C("1")
	c.x = "2"

	assert 2 == c.x