def test_no_fields(self):

@dataclass

class C:

pass

o = C()

self.assertEqual(len(fields(C)), 0)

def test_no_fields_but_member_variable(self):

@dataclass

class C:

i = 0

o = C()

self.assertEqual(len(fields(C)), 0)

def test_one_field_no_default(self):

@dataclass

class C:

x: int

o = C(42)

self.assertEqual(o.x, 42)

def test_field_default_default_factory_error(self):

msg = "cannot specify both default and default_factory"

with self.assertRaisesRegex(ValueError, msg):

@dataclass

class C:

x: int = field(default=1, default_factory=int)

def test_field_repr(self):

int_field = field(default=1, init=True, repr=False)

int_field.name = "id"

repr_output = repr(int_field)

expected_output = "Field(name='id',type=None," \

f"default=1,default_factory={MISSING!r}," \

"init=True,repr=False,hash=None," \

"compare=True,metadata=mappingproxy({})," \

f"kw_only={MISSING!r}," \

"_field_type=None)"

self.assertEqual(repr_output, expected_output)

def test_named_init_params(self):

@dataclass

class C:

x: int

o = C(x=32)

self.assertEqual(o.x, 32)

def test_two_fields_one_default(self):

@dataclass

class C:

x: int

y: int = 0

o = C(3)

self.assertEqual((o.x, o.y), (3, 0))

# Non-defaults following defaults.

with self.assertRaisesRegex(TypeError,

"non-default argument 'y' follows "

"default argument"):

@dataclass

class C:

x: int = 0

y: int

# A derived class adds a non-default field after a default one.

with self.assertRaisesRegex(TypeError,

"non-default argument 'y' follows "

"default argument"):

@dataclass

class B:

x: int = 0

@dataclass

class C(B):

y: int

# Override a base class field and add a default to

# a field which didn't use to have a default.

with self.assertRaisesRegex(TypeError,

"non-default argument 'y' follows "

"default argument"):

@dataclass

class B:

x: int

y: int

@dataclass

class C(B):

x: int = 0

def test_overwrite_hash(self):

# Test that declaring this class isn't an error. It should

# use the user-provided __hash__.

@dataclass(frozen=True)

class C:

x: int

def __hash__(self):

return 301

self.assertEqual(hash(C(100)), 301)

# Test that declaring this class isn't an error. It should

# use the generated __hash__.

@dataclass(frozen=True)

class C:

x: int

def __eq__(self, other):

return False

self.assertEqual(hash(C(100)), hash((100,)))

# But this one should generate an exception, because with

# unsafe_hash=True, it's an error to have a __hash__ defined.

with self.assertRaisesRegex(TypeError,

'Cannot overwrite attribute __hash__'):

@dataclass(unsafe_hash=True)

class C:

def __hash__(self):

pass

# Creating this class should not generate an exception,

# because even though __hash__ exists before @dataclass is

# called, (due to __eq__ being defined), since it's None

# that's okay.

@dataclass(unsafe_hash=True)

class C:

x: int

def __eq__(self):

pass

# The generated hash function works as we'd expect.

self.assertEqual(hash(C(10)), hash((10,)))

# Creating this class should generate an exception, because

# __hash__ exists and is not None, which it would be if it

# had been auto-generated due to __eq__ being defined.

with self.assertRaisesRegex(TypeError,

'Cannot overwrite attribute __hash__'):

@dataclass(unsafe_hash=True)

class C:

x: int

def __eq__(self):

pass

def __hash__(self):

pass

def test_overwrite_fields_in_derived_class(self):

# Note that x from C1 replaces x in Base, but the order remains

# the same as defined in Base.

@dataclass

class Base:

x: Any = 15.0

y: int = 0

@dataclass

class C1(Base):

z: int = 10

x: int = 15

o = Base()

self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.Base(x=15.0, y=0)')

o = C1()

self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.C1(x=15, y=0, z=10)')

o = C1(x=5)

self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.C1(x=5, y=0, z=10)')

def test_field_named_self(self):

@dataclass

class C:

self: str

c=C('foo')

self.assertEqual(c.self, 'foo')

# Make sure the first parameter is not named 'self'.

sig = inspect.signature(C.__init__)

first = next(iter(sig.parameters))

self.assertNotEqual('self', first)

# But we do use 'self' if no field named self.

@dataclass

class C:

selfx: str

# Make sure the first parameter is named 'self'.

sig = inspect.signature(C.__init__)

first = next(iter(sig.parameters))

self.assertEqual('self', first)

def test_field_named_object(self):

@dataclass

class C:

object: str

c = C('foo')

self.assertEqual(c.object, 'foo')

def test_field_named_object_frozen(self):

@dataclass(frozen=True)

class C:

object: str

c = C('foo')

self.assertEqual(c.object, 'foo')

def test_field_named_like_builtin(self):

# Attribute names can shadow built-in names

# since code generation is used.

# Ensure that this is not happening.

exclusions = {'None', 'True', 'False'}

builtins_names = sorted(

b for b in builtins.__dict__.keys()

if not b.startswith('__') and b not in exclusions

)

attributes = [(name, str) for name in builtins_names]

C = make_dataclass('C', attributes)

c = C(*[name for name in builtins_names])

for name in builtins_names:

self.assertEqual(getattr(c, name), name)

def test_field_named_like_builtin_frozen(self):

# Attribute names can shadow built-in names

# since code generation is used.

# Ensure that this is not happening

# for frozen data classes.

exclusions = {'None', 'True', 'False'}

builtins_names = sorted(

b for b in builtins.__dict__.keys()

if not b.startswith('__') and b not in exclusions

)

attributes = [(name, str) for name in builtins_names]

C = make_dataclass('C', attributes, frozen=True)

c = C(*[name for name in builtins_names])

for name in builtins_names:

self.assertEqual(getattr(c, name), name)

def test_0_field_compare(self):

# Ensure that order=False is the default.

@dataclass

class C0:

pass

@dataclass(order=False)

class C1:

pass

for cls in [C0, C1]:

with self.subTest(cls=cls):

self.assertEqual(cls(), cls())

for idx, fn in enumerate([lambda a, b: a < b,

lambda a, b: a <= b,

lambda a, b: a > b,

lambda a, b: a >= b]):

with self.subTest(idx=idx):

with self.assertRaisesRegex(TypeError,

f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):

fn(cls(), cls())

@dataclass(order=True)

class C:

pass

self.assertLessEqual(C(), C())

self.assertGreaterEqual(C(), C())

def test_1_field_compare(self):

# Ensure that order=False is the default.

@dataclass

class C0:

x: int

@dataclass(order=False)

class C1:

x: int

for cls in [C0, C1]:

with self.subTest(cls=cls):

self.assertEqual(cls(1), cls(1))

self.assertNotEqual(cls(0), cls(1))

for idx, fn in enumerate([lambda a, b: a < b,

lambda a, b: a <= b,

lambda a, b: a > b,

lambda a, b: a >= b]):

with self.subTest(idx=idx):

with self.assertRaisesRegex(TypeError,

f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):

fn(cls(0), cls(0))

@dataclass(order=True)

class C:

x: int

self.assertLess(C(0), C(1))

self.assertLessEqual(C(0), C(1))

self.assertLessEqual(C(1), C(1))

self.assertGreater(C(1), C(0))

self.assertGreaterEqual(C(1), C(0))

self.assertGreaterEqual(C(1), C(1))

def test_simple_compare(self):

# Ensure that order=False is the default.

@dataclass

class C0:

x: int

y: int

@dataclass(order=False)

class C1:

x: int

y: int

for cls in [C0, C1]:

with self.subTest(cls=cls):

self.assertEqual(cls(0, 0), cls(0, 0))

self.assertEqual(cls(1, 2), cls(1, 2))

self.assertNotEqual(cls(1, 0), cls(0, 0))

self.assertNotEqual(cls(1, 0), cls(1, 1))

for idx, fn in enumerate([lambda a, b: a < b,

lambda a, b: a <= b,

lambda a, b: a > b,

lambda a, b: a >= b]):

with self.subTest(idx=idx):

with self.assertRaisesRegex(TypeError,

f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):

fn(cls(0, 0), cls(0, 0))

@dataclass(order=True)

class C:

x: int

y: int

for idx, fn in enumerate([lambda a, b: a == b,

lambda a, b: a <= b,

lambda a, b: a >= b]):

with self.subTest(idx=idx):

self.assertTrue(fn(C(0, 0), C(0, 0)))

for idx, fn in enumerate([lambda a, b: a < b,

lambda a, b: a <= b,

lambda a, b: a != b]):

with self.subTest(idx=idx):

self.assertTrue(fn(C(0, 0), C(0, 1)))

self.assertTrue(fn(C(0, 1), C(1, 0)))

self.assertTrue(fn(C(1, 0), C(1, 1)))

for idx, fn in enumerate([lambda a, b: a > b,

lambda a, b: a >= b,

lambda a, b: a != b]):

with self.subTest(idx=idx):

self.assertTrue(fn(C(0, 1), C(0, 0)))

self.assertTrue(fn(C(1, 0), C(0, 1)))

self.assertTrue(fn(C(1, 1), C(1, 0)))

def test_compare_subclasses(self):

# Comparisons fail for subclasses, even if no fields

# are added.

@dataclass

class B:

i: int

@dataclass

class C(B):

pass

for idx, (fn, expected) in enumerate([(lambda a, b: a == b, False),

(lambda a, b: a != b, True)]):

with self.subTest(idx=idx):

self.assertEqual(fn(B(0), C(0)), expected)

for idx, fn in enumerate([lambda a, b: a < b,

lambda a, b: a <= b,

lambda a, b: a > b,

lambda a, b: a >= b]):

with self.subTest(idx=idx):

with self.assertRaisesRegex(TypeError,

"not supported between instances of 'B' and 'C'"):

fn(B(0), C(0))

def test_eq_order(self):

# Test combining eq and order.

for (eq, order, result ) in [

(False, False, 'neither'),

(False, True, 'exception'),

(True, False, 'eq_only'),

(True, True, 'both'),

]:

with self.subTest(eq=eq, order=order):

if result == 'exception':

with self.assertRaisesRegex(ValueError, 'eq must be true if order is true'):

@dataclass(eq=eq, order=order)

class C:

pass

else:

@dataclass(eq=eq, order=order)

class C:

pass

if result == 'neither':

self.assertNotIn('__eq__', C.__dict__)

self.assertNotIn('__lt__', C.__dict__)

self.assertNotIn('__le__', C.__dict__)

self.assertNotIn('__gt__', C.__dict__)

self.assertNotIn('__ge__', C.__dict__)

elif result == 'both':

self.assertIn('__eq__', C.__dict__)

self.assertIn('__lt__', C.__dict__)

self.assertIn('__le__', C.__dict__)

self.assertIn('__gt__', C.__dict__)

self.assertIn('__ge__', C.__dict__)

elif result == 'eq_only':

self.assertIn('__eq__', C.__dict__)

self.assertNotIn('__lt__', C.__dict__)

self.assertNotIn('__le__', C.__dict__)

self.assertNotIn('__gt__', C.__dict__)

self.assertNotIn('__ge__', C.__dict__)

else:

assert False, f'unknown result {result!r}'

def test_field_no_default(self):

@dataclass

class C:

x: int = field()

self.assertEqual(C(5).x, 5)

with self.assertRaisesRegex(TypeError,

r"__init__\(\) missing 1 required "

"positional argument: 'x'"):

C()

def test_field_default(self):

default = object()

@dataclass

class C:

x: object = field(default=default)

self.assertIs(C.x, default)

c = C(10)

self.assertEqual(c.x, 10)

# If we delete the instance attribute, we should then see the

# class attribute.

del c.x

self.assertIs(c.x, default)

self.assertIs(C().x, default)

def test_not_in_repr(self):

@dataclass

class C:

x: int = field(repr=False)

with self.assertRaises(TypeError):

C()

c = C(10)

self.assertEqual(repr(c), 'TestCase.test_not_in_repr.<locals>.C()')

@dataclass

class C:

x: int = field(repr=False)

y: int

c = C(10, 20)

self.assertEqual(repr(c), 'TestCase.test_not_in_repr.<locals>.C(y=20)')

def test_not_in_compare(self):

@dataclass

class C:

x: int = 0

y: int = field(compare=False, default=4)

self.assertEqual(C(), C(0, 20))

self.assertEqual(C(1, 10), C(1, 20))

self.assertNotEqual(C(3), C(4, 10))

self.assertNotEqual(C(3, 10), C(4, 10))

def test_no_unhashable_default(self):

# See bpo-44674.

class Unhashable:

__hash__ = None

unhashable_re = 'mutable default .* for field a is not allowed'

with self.assertRaisesRegex(ValueError, unhashable_re):

@dataclass

class A:

a: dict = {}

with self.assertRaisesRegex(ValueError, unhashable_re):

@dataclass

class A:

a: Any = Unhashable()

# Make sure that the machinery looking for hashability is using the

# class's __hash__, not the instance's __hash__.

with self.assertRaisesRegex(ValueError, unhashable_re):

unhashable = Unhashable()

# This shouldn't make the variable hashable.

unhashable.__hash__ = lambda: 0

@dataclass

class A:

a: Any = unhashable

def test_hash_field_rules(self):

# Test all 6 cases of:

# hash=True/False/None

# compare=True/False

for (hash_, compare, result ) in [

(True, False, 'field' ),

(True, True, 'field' ),

(False, False, 'absent'),

(False, True, 'absent'),

(None, False, 'absent'),

(None, True, 'field' ),

]:

with self.subTest(hash=hash_, compare=compare):

@dataclass(unsafe_hash=True)

class C:

x: int = field(compare=compare, hash=hash_, default=5)

if result == 'field':

# __hash__ contains the field.

self.assertEqual(hash(C(5)), hash((5,)))

elif result == 'absent':

# The field is not present in the hash.

self.assertEqual(hash(C(5)), hash(()))

else:

assert False, f'unknown result {result!r}'

def test_init_false_no_default(self):

# If init=False and no default value, then the field won't be

# present in the instance.

@dataclass

class C:

x: int = field(init=False)

self.assertNotIn('x', C().__dict__)

@dataclass

class C:

x: int

y: int = 0

z: int = field(init=False)

t: int = 10

self.assertNotIn('z', C(0).__dict__)

self.assertEqual(vars(C(5)), {'t': 10, 'x': 5, 'y': 0})

def test_class_marker(self):

@dataclass

class C:

x: int

y: str = field(init=False, default=None)

z: str = field(repr=False)

the_fields = fields(C)

# the_fields is a tuple of 3 items, each value

# is in __annotations__.

self.assertIsInstance(the_fields, tuple)

for f in the_fields:

self.assertIs(type(f), Field)

self.assertIn(f.name, C.__annotations__)

self.assertEqual(len(the_fields), 3)

self.assertEqual(the_fields[0].name, 'x')

self.assertEqual(the_fields[0].type, int)

self.assertFalse(hasattr(C, 'x'))

self.assertTrue (the_fields[0].init)

self.assertTrue (the_fields[0].repr)

self.assertEqual(the_fields[1].name, 'y')

self.assertEqual(the_fields[1].type, str)

self.assertIsNone(getattr(C, 'y'))

self.assertFalse(the_fields[1].init)

self.assertTrue (the_fields[1].repr)

self.assertEqual(the_fields[2].name, 'z')

self.assertEqual(the_fields[2].type, str)

self.assertFalse(hasattr(C, 'z'))

self.assertTrue (the_fields[2].init)

self.assertFalse(the_fields[2].repr)

def test_field_order(self):

@dataclass

class B:

a: str = 'B:a'

b: str = 'B:b'

c: str = 'B:c'

@dataclass

class C(B):

b: str = 'C:b'

self.assertEqual([(f.name, f.default) for f in fields(C)],

[('a', 'B:a'),

('b', 'C:b'),

('c', 'B:c')])

@dataclass

class D(B):

c: str = 'D:c'

self.assertEqual([(f.name, f.default) for f in fields(D)],

[('a', 'B:a'),

('b', 'B:b'),

('c', 'D:c')])

@dataclass

class E(D):

a: str = 'E:a'

d: str = 'E:d'

self.assertEqual([(f.name, f.default) for f in fields(E)],

[('a', 'E:a'),

('b', 'B:b'),

('c', 'D:c'),

('d', 'E:d')])

def test_class_attrs(self):

# We only have a class attribute if a default value is

# specified, either directly or via a field with a default.

default = object()

@dataclass

class C:

x: int

y: int = field(repr=False)

z: object = default

t: int = field(default=100)

self.assertFalse(hasattr(C, 'x'))

self.assertFalse(hasattr(C, 'y'))

self.assertIs (C.z, default)

self.assertEqual(C.t, 100)

def test_disallowed_mutable_defaults(self):

# For the known types, don't allow mutable default values.

for typ, empty, non_empty in [(list, [], [1]),

(dict, {}, {0:1}),

(set, set(), set([1])),

]:

with self.subTest(typ=typ):

# Can't use a zero-length value.

with self.assertRaisesRegex(ValueError,

f'mutable default {typ} for field '

'x is not allowed'):

@dataclass

class Point:

x: typ = empty

# Nor a non-zero-length value

with self.assertRaisesRegex(ValueError,

f'mutable default {typ} for field '

'y is not allowed'):

@dataclass

class Point:

y: typ = non_empty

# Check subtypes also fail.

class Subclass(typ): pass

with self.assertRaisesRegex(ValueError,

f"mutable default .*Subclass'>"

' for field z is not allowed'

):

@dataclass

class Point:

z: typ = Subclass()

# Because this is a ClassVar, it can be mutable.

@dataclass

class C:

z: ClassVar[typ] = typ()

# Because this is a ClassVar, it can be mutable.

@dataclass

class C:

x: ClassVar[typ] = Subclass()

def test_deliberately_mutable_defaults(self):

# If a mutable default isn't in the known list of

# (list, dict, set), then it's okay.

class Mutable:

def __init__(self):

self.l = []

@dataclass

class C:

x: Mutable

# These 2 instances will share this value of x.

lst = Mutable()

o1 = C(lst)

o2 = C(lst)

self.assertEqual(o1, o2)

o1.x.l.extend([1, 2])

self.assertEqual(o1, o2)

self.assertEqual(o1.x.l, [1, 2])

self.assertIs(o1.x, o2.x)

def test_no_options(self):

# Call with dataclass().

@dataclass()

class C:

x: int

self.assertEqual(C(42).x, 42)

def test_not_tuple(self):

# Make sure we can't be compared to a tuple.

@dataclass

class Point:

x: int

y: int

self.assertNotEqual(Point(1, 2), (1, 2))

# And that we can't compare to another unrelated dataclass.

@dataclass

class C:

x: int

y: int

self.assertNotEqual(Point(1, 3), C(1, 3))

def test_not_other_dataclass(self):

# Test that some of the problems with namedtuple don't happen

# here.

@dataclass

class Point3D:

x: int

y: int

z: int

@dataclass

class Date:

year: int

month: int

day: int

self.assertNotEqual(Point3D(2017, 6, 3), Date(2017, 6, 3))

self.assertNotEqual(Point3D(1, 2, 3), (1, 2, 3))

# Make sure we can't unpack.

with self.assertRaisesRegex(TypeError, 'unpack'):

x, y, z = Point3D(4, 5, 6)

# Make sure another class with the same field names isn't

# equal.

@dataclass

class Point3Dv1:

x: int = 0

y: int = 0

z: int = 0

self.assertNotEqual(Point3D(0, 0, 0), Point3Dv1())

def test_function_annotations(self):

# Some dummy class and instance to use as a default.

class F:

pass

f = F()

def validate_class(cls):

# First, check __annotations__, even though they're not

# function annotations.

self.assertEqual(cls.__annotations__['i'], int)

self.assertEqual(cls.__annotations__['j'], str)

self.assertEqual(cls.__annotations__['k'], F)

self.assertEqual(cls.__annotations__['l'], float)

self.assertEqual(cls.__annotations__['z'], complex)

# Verify __init__.

signature = inspect.signature(cls.__init__)

# Check the return type, should be None.

self.assertIs(signature.return_annotation, None)

# Check each parameter.

params = iter(signature.parameters.values())

param = next(params)

# This is testing an internal name, and probably shouldn't be tested.

self.assertEqual(param.name, 'self')

param = next(params)

self.assertEqual(param.name, 'i')

self.assertIs (param.annotation, int)

self.assertEqual(param.default, inspect.Parameter.empty)

self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)

param = next(params)

self.assertEqual(param.name, 'j')

self.assertIs (param.annotation, str)

self.assertEqual(param.default, inspect.Parameter.empty)

self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)

param = next(params)

self.assertEqual(param.name, 'k')

self.assertIs (param.annotation, F)

# Don't test for the default, since it's set to MISSING.

self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)

param = next(params)

self.assertEqual(param.name, 'l')

self.assertIs (param.annotation, float)

# Don't test for the default, since it's set to MISSING.

self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)

self.assertRaises(StopIteration, next, params)

@dataclass

class C:

i: int

j: str

k: F = f

l: float=field(default=None)

z: complex=field(default=3+4j, init=False)

validate_class(C)

# Now repeat with __hash__.

@dataclass(frozen=True, unsafe_hash=True)

class C:

i: int

j: str

k: F = f

l: float=field(default=None)

z: complex=field(default=3+4j, init=False)

validate_class(C)

def test_missing_default(self):

# Test that MISSING works the same as a default not being

# specified.

@dataclass

class C:

x: int=field(default=MISSING)

with self.assertRaisesRegex(TypeError,

r'__init__\(\) missing 1 required '

'positional argument'):

C()

self.assertNotIn('x', C.__dict__)

@dataclass

class D:

x: int

with self.assertRaisesRegex(TypeError,

r'__init__\(\) missing 1 required '

'positional argument'):

D()

self.assertNotIn('x', D.__dict__)

def test_missing_default_factory(self):

# Test that MISSING works the same as a default factory not

# being specified (which is really the same as a default not

# being specified, too).

@dataclass

class C:

x: int=field(default_factory=MISSING)

with self.assertRaisesRegex(TypeError,

r'__init__\(\) missing 1 required '

'positional argument'):

C()

self.assertNotIn('x', C.__dict__)

@dataclass

class D:

x: int=field(default=MISSING, default_factory=MISSING)

with self.assertRaisesRegex(TypeError,

r'__init__\(\) missing 1 required '

'positional argument'):

D()

self.assertNotIn('x', D.__dict__)

def test_missing_repr(self):

self.assertIn('MISSING_TYPE object', repr(MISSING))

def test_dont_include_other_annotations(self):

@dataclass

class C:

i: int

def foo(self) -> int:

return 4

@property

def bar(self) -> int:

return 5

self.assertEqual(list(C.__annotations__), ['i'])

self.assertEqual(C(10).foo(), 4)

self.assertEqual(C(10).bar, 5)

self.assertEqual(C(10).i, 10)

def test_post_init(self):

# Just make sure it gets called

@dataclass

class C:

def __post_init__(self):

raise CustomError()

with self.assertRaises(CustomError):

C()

@dataclass

class C:

i: int = 10

def __post_init__(self):

if self.i == 10:

raise CustomError()

with self.assertRaises(CustomError):

C()

# post-init gets called, but doesn't raise. This is just

# checking that self is used correctly.

C(5)

# If there's not an __init__, then post-init won't get called.

@dataclass(init=False)

class C:

def __post_init__(self):

raise CustomError()

# Creating the class won't raise

C()

@dataclass

class C:

x: int = 0

def __post_init__(self):

self.x *= 2

self.assertEqual(C().x, 0)

self.assertEqual(C(2).x, 4)

# Make sure that if we're frozen, post-init can't set

# attributes.

@dataclass(frozen=True)

class C:

x: int = 0

def __post_init__(self):

self.x *= 2

with self.assertRaises(FrozenInstanceError):

C()

def test_post_init_super(self):

# Make sure super() post-init isn't called by default.

class B:

def __post_init__(self):

raise CustomError()

@dataclass

class C(B):

def __post_init__(self):

self.x = 5

self.assertEqual(C().x, 5)

# Now call super(), and it will raise.

@dataclass

class C(B):

def __post_init__(self):

super().__post_init__()

with self.assertRaises(CustomError):

C()

# Make sure post-init is called, even if not defined in our

# class.

@dataclass

class C(B):

pass

with self.assertRaises(CustomError):

C()

def test_post_init_staticmethod(self):

flag = False

@dataclass

class C:

x: int

y: int

@staticmethod

def __post_init__():

nonlocal flag

flag = True

self.assertFalse(flag)