def test_make_derived(self):
@dataclass
class Base:
x: int
y: int
C = make_class('C',
[field('z', int),
field('x', int),
],
bases=(Base,))
self.assertEqual(repr(C(4,5,6)), 'C(x=4,y=5,z=6)')
def test_make_invalid_fields(self):
with self.assertRaises(TypeError) as ex:
C = make_class('C',
[field('x', int),
field(),
])
self.assertEqual(str(ex.exception), 'name must be specified for field #2')
with self.assertRaises(TypeError) as ex:
C = make_class('C',
[field('x'),
])
self.assertEqual(str(ex.exception), "type must be specified for field 'x'")
def test_make_derived_defaults(self):
@dataclass
class Base:
x: int = 5
y: int = 20
C = make_class('C',
[field('z', int, default=30),
field('x', int, default=10),
],
bases=(Base,))
self.assertEqual(repr(C()), 'C(x=10,y=20,z=30)')
C = make_class('C',
[field('z', int, default=30),
field('x', int, default=10, init=False),
],
bases=(Base,))
self.assertEqual(repr(C(1)), 'C(x=10,y=1,z=30)')
def test_class_marker(self):
@dataclass
class C:
x: int
y: str = field(init=False, default=None)
z: str = field(repr=False)
# And the equivalent dynamically created class:
D = make_class('D',
[field('x', int),
field('y', str, init=False, default=None),
field('z', str, repr=False),
])
for cls in C, D:
# __dataclass_fields__ is a list of 3 elements, all of which are in __annotations__
self.assertIsInstance(cls.__dataclass_fields__, list)
for f in cls.__dataclass_fields__:
self.assertIn(f.name, cls.__annotations__)
self.assertEqual(len(cls.__dataclass_fields__), 3)
self.assertEqual(cls.__dataclass_fields__[0].name, 'x')
self.assertEqual(cls.__dataclass_fields__[0].type, int)
self.assertFalse(hasattr(cls, 'x'))
self.assertTrue (cls.__dataclass_fields__[0].init)
self.assertTrue (cls.__dataclass_fields__[0].repr)
self.assertEqual(cls.__dataclass_fields__[1].name, 'y')
self.assertEqual(cls.__dataclass_fields__[1].type, str)
self.assertIsNone(getattr(cls, 'y'))
self.assertFalse(cls.__dataclass_fields__[1].init)
self.assertTrue (cls.__dataclass_fields__[1].repr)
self.assertEqual(cls.__dataclass_fields__[2].name, 'z')
self.assertEqual(cls.__dataclass_fields__[2].type, str)
self.assertFalse(hasattr(cls, 'z'))
self.assertTrue (cls.__dataclass_fields__[2].init)
self.assertFalse(cls.__dataclass_fields__[2].repr)
class C:
i: int
j: str
k: F=f
l: float=field(default=None)
z: complex=field(default=3+4j, init=False)
class Point:
x: int = field(type=str)
class Point:
x: int = field('x')
class C:
x: int
y: int = field(repr=False)
z: object = default
t: int = field(default=100)
class C:
x: int
y: str = field(init=False, default=None)
z: str = field(repr=False)
class C:
x: int
y: int = 0
z: int = field(init=False)
t: int
class C:
x: int = field(init=False)
class C:
x: int = 0
y: int = field(cmp=False, default=4)
class C:
x: int = field(repr=False)
y: int
class C:
x: object = field(default=default)
class C:
x: int = field()
