Lines Matching refs:self
139 def test_is_descriptor(self):
144 self.assertFalse(enum._is_descriptor(obj))
146 self.assertTrue(enum._is_descriptor(obj))
148 def test_sunder(self):
149 for name in self.sunder_names + self.private_and_sunder_names:
150 self.assertTrue(enum._is_sunder(name), '%r is a not sunder name?' % name)
151 for name in self.dunder_names + self.private_names + self.random_names:
152 self.assertFalse(enum._is_sunder(name), '%r is a sunder name?' % name)
154 self.assertTrue(enum._is_sunder(s))
157 self.assertFalse(enum._is_sunder(s))
159 def test_dunder(self):
160 for name in self.dunder_names:
161 self.assertTrue(enum._is_dunder(name), '%r is a not dunder name?' % name)
162 for name in self.sunder_names + self.private_names + self.private_and_sunder_names + self.random_names:
163 self.assertFalse(enum._is_dunder(name), '%r is a dunder name?' % name)
165 self.assertTrue(enum._is_dunder(s))
168 self.assertFalse(enum._is_dunder(s))
171 def test_is_private(self):
172 for name in self.private_names + self.private_and_sunder_names:
173 self.assertTrue(enum._is_private('MyEnum', name), '%r is a not private name?')
174 for name in self.sunder_names + self.dunder_names + self.random_names:
175 self.assertFalse(enum._is_private('MyEnum', name), '%r is a private name?')
177 def test_iter_bits_lsb(self):
178 self.assertEqual(list(_iter_bits_lsb(7)), [1, 2, 4])
179 self.assertRaisesRegex(ValueError, '-8 is not a positive integer', list, _iter_bits_lsb(-8))
186 def __init__(self, fget=None, fset=None, fdel=None, doc=None):
187 self.fget = fget
188 self.fset = fset
189 self.fdel = fdel
192 self.__doc__ = doc
194 def __get__(self, instance, ownerclass):
195 return self.fget(ownerclass)
230 def setUp(self):
231 class BaseEnum(self.enum_type):
233 def first(self):
234 return '%s is first!' % self.name
239 if issubclass(self.enum_type, Flag):
243 self.MainEnum = MainEnum
245 class NewStrEnum(self.enum_type):
246 def __str__(self):
247 return self.name.upper()
249 self.NewStrEnum = NewStrEnum
251 class NewFormatEnum(self.enum_type):
252 def __format__(self, spec):
253 return self.name.upper()
255 self.NewFormatEnum = NewFormatEnum
257 class NewStrFormatEnum(self.enum_type):
258 def __str__(self):
259 return self.name.title()
260 def __format__(self, spec):
261 return ''.join(reversed(self.name))
263 self.NewStrFormatEnum = NewStrFormatEnum
265 class NewBaseEnum(self.enum_type):
266 def __str__(self):
267 return self.name.title()
268 def __format__(self, spec):
269 return ''.join(reversed(self.name))
272 self.NewSubEnum = NewSubEnum
274 self.is_flag = False
275 self.names = ['first', 'second', 'third']
277 self.values = self.names
279 self.values = ['1', '2', '3']
280 elif issubclass(self.enum_type, Flag):
281 self.values = [1, 2, 4]
282 self.is_flag = True
283 self.dupe2 = MainEnum(5)
285 self.values = self.values or [1, 2, 3]
287 if not getattr(self, 'source_values', False):
288 self.source_values = self.values
290 def assertFormatIsValue(self, spec, member):
291 self.assertEqual(spec.format(member), spec.format(member.value))
293 def assertFormatIsStr(self, spec, member):
294 self.assertEqual(spec.format(member), spec.format(str(member)))
296 def test_attribute_deletion(self):
297 class Season(self.enum_type):
305 self.assertTrue(hasattr(Season, 'spam'))
307 self.assertFalse(hasattr(Season, 'spam'))
309 with self.assertRaises(AttributeError):
311 with self.assertRaises(AttributeError):
313 with self.assertRaises(AttributeError):
316 def test_basics(self):
317 TE = self.MainEnum
318 if self.is_flag:
319 self.assertEqual(repr(TE), "<flag 'MainEnum'>")
320 self.assertEqual(str(TE), "<flag 'MainEnum'>")
321 self.assertEqual(format(TE), "<flag 'MainEnum'>")
322 self.assertTrue(TE(5) is self.dupe2)
324 self.assertEqual(repr(TE), "<enum 'MainEnum'>")
325 self.assertEqual(str(TE), "<enum 'MainEnum'>")
326 self.assertEqual(format(TE), "<enum 'MainEnum'>")
327 self.assertEqual(list(TE), [TE.first, TE.second, TE.third])
328 self.assertEqual(
330 self.names,
332 self.assertEqual(
334 self.values,
336 self.assertEqual(
340 for member, name in zip(TE, self.names, strict=True):
341 self.assertIs(TE[name], member)
342 for member, value in zip(TE, self.values, strict=True):
343 self.assertIs(TE(value), member)
345 self.assertTrue(TE.dupe is TE('third') is TE['dupe'])
347 self.assertTrue(TE.dupe is TE('3') is TE['dupe'])
349 self.assertTrue(TE.dupe is TE(3) is TE['dupe'])
351 self.assertTrue(TE.dupe is TE(self.values[2]) is TE['dupe'])
353 def test_bool_is_true(self):
354 class Empty(self.enum_type):
356 self.assertTrue(Empty)
358 self.assertTrue(self.MainEnum)
359 for member in self.MainEnum:
360 self.assertTrue(member)
362 def test_changing_member_fails(self):
363 MainEnum = self.MainEnum
364 with self.assertRaises(AttributeError):
365 self.MainEnum.second = 'really first'
371 def test_contains_er(self):
372 MainEnum = self.MainEnum
373 self.assertIn(MainEnum.third, MainEnum)
374 with self.assertRaises(TypeError):
375 with self.assertWarns(DeprecationWarning):
376 self.source_values[1] in MainEnum
377 with self.assertRaises(TypeError):
378 with self.assertWarns(DeprecationWarning):
381 self.assertIn(val, MainEnum)
386 self.assertNotIn(OtherEnum.two, MainEnum)
392 def test_contains_tf(self):
393 MainEnum = self.MainEnum
394 self.assertIn(MainEnum.first, MainEnum)
395 self.assertTrue(self.source_values[0] in MainEnum)
396 self.assertFalse('first' in MainEnum)
398 self.assertIn(val, MainEnum)
403 self.assertNotIn(OtherEnum.two, MainEnum)
405 def test_dir_on_class(self):
406 TE = self.MainEnum
407 self.assertEqual(set(dir(TE)), set(enum_dir(TE)))
409 def test_dir_on_item(self):
410 TE = self.MainEnum
411 self.assertEqual(set(dir(TE.first)), set(member_dir(TE.first)))
413 def test_dir_with_added_behavior(self):
414 class Test(self.enum_type):
417 def wowser(self):
418 return ("Wowser! I'm %s!" % self.name)
419 self.assertTrue('wowser' not in dir(Test))
420 self.assertTrue('wowser' in dir(Test.this))
422 def test_dir_on_sub_with_behavior_on_super(self):
424 class SuperEnum(self.enum_type):
425 def invisible(self):
429 self.assertTrue('invisible' not in dir(SubEnum))
430 self.assertTrue('invisible' in dir(SubEnum.sample))
432 def test_dir_on_sub_with_behavior_including_instance_dict_on_super(self):
434 class SuperEnum(self.enum_type):
436 new = self.enum_type._member_type_.__new__
437 if self.enum_type._member_type_ is object:
449 sample = self.source_values[1]
450 self.assertTrue('description' not in dir(SubEnum))
451 self.assertTrue('description' in dir(SubEnum.sample), dir(SubEnum.sample))
453 def test_enum_in_enum_out(self):
454 Main = self.MainEnum
455 self.assertIs(Main(Main.first), Main.first)
457 def test_hash(self):
458 MainEnum = self.MainEnum
463 self.assertEqual(mapping[MainEnum.second], '0315')
465 def test_invalid_names(self):
466 with self.assertRaises(ValueError):
467 class Wrong(self.enum_type):
469 with self.assertRaises(ValueError):
470 class Wrong(self.enum_type):
472 with self.assertRaises(ValueError):
473 class Wrong(self.enum_type):
475 with self.assertRaises(ValueError):
476 class Wrong(self.enum_type):
478 with self.assertRaises(ValueError):
479 class Wrong(self.enum_type):
482 def test_object_str_override(self):
484 class Generic(self.enum_type):
485 item = self.source_values[2]
486 def __repr__(self):
487 return "%s.test" % (self._name_, )
489 self.assertEqual(str(Generic.item), 'item.test')
491 def test_overridden_str(self):
492 NS = self.NewStrEnum
493 self.assertEqual(str(NS.first), NS.first.name.upper())
494 self.assertEqual(format(NS.first), NS.first.name.upper())
496 def test_overridden_str_format(self):
497 NSF = self.NewStrFormatEnum
498 self.assertEqual(str(NSF.first), NSF.first.name.title())
499 self.assertEqual(format(NSF.first), ''.join(reversed(NSF.first.name)))
501 def test_overridden_str_format_inherited(self):
502 NSE = self.NewSubEnum
503 self.assertEqual(str(NSE.first), NSE.first.name.title())
504 self.assertEqual(format(NSE.first), ''.join(reversed(NSE.first.name)))
506 def test_programmatic_function_string(self):
507 MinorEnum = self.enum_type('MinorEnum', 'june july august')
509 self.assertEqual(len(lst), len(MinorEnum))
510 self.assertEqual(len(MinorEnum), 3, MinorEnum)
511 self.assertEqual(
515 values = self.values
516 if self.enum_type is StrEnum:
520 self.assertEqual(e.value, av, list(MinorEnum))
521 self.assertEqual(e.name, month)
523 self.assertEqual(e, av)
525 self.assertNotEqual(e, av)
526 self.assertIn(e, MinorEnum)
527 self.assertIs(type(e), MinorEnum)
528 self.assertIs(e, MinorEnum(av))
530 def test_programmatic_function_string_list(self):
531 MinorEnum = self.enum_type('MinorEnum', ['june', 'july', 'august'])
533 self.assertEqual(len(lst), len(MinorEnum))
534 self.assertEqual(len(MinorEnum), 3, MinorEnum)
535 self.assertEqual(
539 values = self.values
540 if self.enum_type is StrEnum:
544 self.assertEqual(e.value, av)
545 self.assertEqual(e.name, month)
547 self.assertEqual(e, av)
549 self.assertNotEqual(e, av)
550 self.assertIn(e, MinorEnum)
551 self.assertIs(type(e), MinorEnum)
552 self.assertIs(e, MinorEnum(av))
554 def test_programmatic_function_iterable(self):
555 MinorEnum = self.enum_type(
557 (('june', self.source_values[0]), ('july', self.source_values[1]), ('august', self.source_values[2]))
560 self.assertEqual(len(lst), len(MinorEnum))
561 self.assertEqual(len(MinorEnum), 3, MinorEnum)
562 self.assertEqual(
566 for month, av in zip('june july august'.split(), self.values):
568 self.assertEqual(e.value, av)
569 self.assertEqual(e.name, month)
571 self.assertEqual(e, av)
573 self.assertNotEqual(e, av)
574 self.assertIn(e, MinorEnum)
575 self.assertIs(type(e), MinorEnum)
576 self.assertIs(e, MinorEnum(av))
578 def test_programmatic_function_from_dict(self):
579 MinorEnum = self.enum_type(
581 OrderedDict((('june', self.source_values[0]), ('july', self.source_values[1]), ('august', self.source_values[2])))
584 self.assertEqual(len(lst), len(MinorEnum))
585 self.assertEqual(len(MinorEnum), 3, MinorEnum)
586 self.assertEqual(
590 for month, av in zip('june july august'.split(), self.values):
593 self.assertEqual(e, av)
595 self.assertNotEqual(e, av)
596 self.assertIn(e, MinorEnum)
597 self.assertIs(type(e), MinorEnum)
598 self.assertIs(e, MinorEnum(av))
600 def test_repr(self):
601 TE = self.MainEnum
602 if self.is_flag:
603 self.assertEqual(repr(TE(0)), "<MainEnum: 0>")
604 self.assertEqual(repr(TE.dupe), "<MainEnum.dupe: 3>")
605 self.assertEqual(repr(self.dupe2), "<MainEnum.first|third: 5>")
607 self.assertEqual(repr(TE.dupe), "<MainEnum.third: 'third'>")
609 self.assertEqual(repr(TE.dupe), "<MainEnum.third: %r>" % (self.values[2], ), TE._value_repr_)
610 for name, value, member in zip(self.names, self.values, TE, strict=True):
611 self.assertEqual(repr(member), "<MainEnum.%s: %r>" % (member.name, member.value))
613 def test_repr_override(self):
614 class Generic(self.enum_type):
618 def __repr__(self):
619 return "don't you just love shades of %s?" % self.name
620 self.assertEqual(
625 def test_inherited_repr(self):
626 class MyEnum(self.enum_type):
627 def __repr__(self):
628 return "My name is %s." % self.name
633 self.assertEqual(repr(MySubEnum.that), "My name is that.")
635 def test_multiple_superclasses_repr(self):
640 self.assertEqual(repr(E.A), "<E.A: 1>")
642 def test_reversed_iteration_order(self):
643 self.assertEqual(
644 list(reversed(self.MainEnum)),
645 [self.MainEnum.third, self.MainEnum.second, self.MainEnum.first],
650 def test_str(self):
651 TE = self.MainEnum
652 if self.is_flag:
653 self.assertEqual(str(TE(0)), "MainEnum(0)")
654 self.assertEqual(str(TE.dupe), "MainEnum.dupe")
655 self.assertEqual(str(self.dupe2), "MainEnum.first|third")
657 self.assertEqual(str(TE.dupe), "MainEnum.third")
658 for name, value, member in zip(self.names, self.values, TE, strict=True):
659 self.assertEqual(str(member), "MainEnum.%s" % (member.name, ))
661 def test_format(self):
662 TE = self.MainEnum
663 if self.is_flag:
664 self.assertEqual(format(TE.dupe), "MainEnum.dupe")
665 self.assertEqual(format(self.dupe2), "MainEnum.first|third")
667 self.assertEqual(format(TE.dupe), "MainEnum.third")
668 for name, value, member in zip(self.names, self.values, TE, strict=True):
669 self.assertEqual(format(member), "MainEnum.%s" % (member.name, ))
671 def test_overridden_format(self):
672 NF = self.NewFormatEnum
673 self.assertEqual(str(NF.first), "NewFormatEnum.first", '%s %r' % (NF.__str__, NF.first))
674 self.assertEqual(format(NF.first), "FIRST")
676 def test_format_specs(self):
677 TE = self.MainEnum
678 self.assertFormatIsStr('{}', TE.second)
679 self.assertFormatIsStr('{:}', TE.second)
680 self.assertFormatIsStr('{:20}', TE.second)
681 self.assertFormatIsStr('{:^20}', TE.second)
682 self.assertFormatIsStr('{:>20}', TE.second)
683 self.assertFormatIsStr('{:<20}', TE.second)
684 self.assertFormatIsStr('{:5.2}', TE.second)
689 def test_str(self):
690 TE = self.MainEnum
691 if self.is_flag:
692 self.assertEqual(str(TE.dupe), "MainEnum.dupe")
693 self.assertEqual(str(self.dupe2), "MainEnum.first|third")
695 self.assertEqual(str(TE.dupe), "MainEnum.third")
696 for name, value, member in zip(self.names, self.values, TE, strict=True):
697 self.assertEqual(str(member), "MainEnum.%s" % (member.name, ))
699 def test_format(self):
700 TE = self.MainEnum
701 if self.is_flag:
702 self.assertEqual(format(TE.dupe), "MainEnum.dupe")
703 self.assertEqual(format(self.dupe2), "MainEnum.first|third")
705 self.assertEqual(format(TE.dupe), "MainEnum.third")
706 for name, value, member in zip(self.names, self.values, TE, strict=True):
707 self.assertEqual(format(member), "MainEnum.%s" % (member.name, ))
709 def test_overridden_format(self):
710 NF = self.NewFormatEnum
711 self.assertEqual(str(NF.first), "NewFormatEnum.first")
712 self.assertEqual(format(NF.first), "FIRST")
714 def test_format_specs(self):
715 TE = self.MainEnum
716 self.assertFormatIsStr('{}', TE.first)
717 self.assertFormatIsStr('{:}', TE.first)
718 self.assertFormatIsStr('{:20}', TE.first)
719 self.assertFormatIsStr('{:^20}', TE.first)
720 self.assertFormatIsStr('{:>20}', TE.first)
721 self.assertFormatIsStr('{:<20}', TE.first)
722 self.assertFormatIsStr('{:5.2}', TE.first)
727 def test_str(self):
728 TE = self.MainEnum
729 if self.is_flag:
730 self.assertEqual(str(TE.dupe), "3")
731 self.assertEqual(str(self.dupe2), "5")
733 self.assertEqual(str(TE.dupe), str(self.values[2]))
734 for name, value, member in zip(self.names, self.values, TE, strict=True):
735 self.assertEqual(str(member), str(value))
737 def test_format(self):
738 TE = self.MainEnum
739 if self.is_flag:
740 self.assertEqual(format(TE.dupe), "3")
741 self.assertEqual(format(self.dupe2), "5")
743 self.assertEqual(format(TE.dupe), format(self.values[2]))
744 for name, value, member in zip(self.names, self.values, TE, strict=True):
745 self.assertEqual(format(member), format(value))
747 def test_overridden_format(self):
748 NF = self.NewFormatEnum
749 self.assertEqual(str(NF.first), str(self.values[0]))
750 self.assertEqual(format(NF.first), "FIRST")
752 def test_format_specs(self):
753 TE = self.MainEnum
754 self.assertFormatIsValue('{}', TE.third)
755 self.assertFormatIsValue('{:}', TE.third)
756 self.assertFormatIsValue('{:20}', TE.third)
757 self.assertFormatIsValue('{:^20}', TE.third)
758 self.assertFormatIsValue('{:>20}', TE.third)
759 self.assertFormatIsValue('{:<20}', TE.third)
761 self.assertFormatIsValue('{:n}', TE.third)
762 self.assertFormatIsValue('{:5.2}', TE.third)
763 self.assertFormatIsValue('{:f}', TE.third)
765 def test_copy(self):
766 TE = self.MainEnum
768 self.assertEqual(copied, TE)
770 self.assertEqual(deep, TE)
775 def test_default_missing_with_wrong_type_value(self):
776 with self.assertRaisesRegex(
780 self.MainEnum('RED')
781 self.assertIs(ctx.exception.__context__, None)
862 def setUp(self):
868 self.Season = Season
876 self.Grades = Grades
883 self.Directional = Directional
889 self.Holiday = Holiday
891 def test_bool(self):
896 self.assertTrue(Logic.true)
897 self.assertTrue(Logic.false)
902 def __bool__(self):
903 return bool(self._value_)
904 self.assertTrue(RealLogic.true)
905 self.assertFalse(RealLogic.false)
910 self.assertTrue(IntLogic.true)
911 self.assertFalse(IntLogic.false)
913 def test_comparisons(self):
914 Season = self.Season
915 with self.assertRaises(TypeError):
917 with self.assertRaises(TypeError):
920 self.assertNotEqual(Season.SPRING, 1)
927 self.assertNotEqual(Season.SPRING, Part.SPRING)
928 with self.assertRaises(TypeError):
932 def test_dir_with_custom_dunders(self):
936 self.assertNotIn('__repr__', cls_dir)
937 self.assertNotIn('__str__', cls_dir)
938 self.assertNotIn('__format__', cls_dir)
939 self.assertNotIn('__init__', cls_dir)
942 def __repr__(self):
943 return object.__repr__(self)
944 def __str__(self):
945 return object.__repr__(self)
946 def __format__(self):
947 return object.__repr__(self)
948 def __init__(self):
951 self.assertIn('__repr__', cls_dir)
952 self.assertIn('__str__', cls_dir)
953 self.assertIn('__format__', cls_dir)
954 self.assertIn('__init__', cls_dir)
956 def test_duplicate_name_error(self):
957 with self.assertRaises(TypeError):
964 with self.assertRaises(TypeError):
969 def red(self):
972 with self.assertRaises(TypeError):
975 def red(self):
981 def test_enum_function_with_qualname(self):
984 self.assertEqual(Theory.__qualname__, 'spanish_inquisition')
986 def test_enum_of_types(self):
992 self.assertEqual(MyTypes.i.value, int)
993 self.assertEqual(MyTypes.f.value, float)
994 self.assertEqual(MyTypes.s.value, str)
1002 self.assertEqual(MyTypes2.a.value, Foo)
1003 self.assertEqual(MyTypes2.b.value, Bar)
1008 self.assertEqual(SpamEnum.spam.value, SpamEnumNotInner)
1010 def test_enum_of_generic_aliases(self):
1014 self.assertEqual(E.a.value, typing.List[int])
1015 self.assertEqual(E.b.value, list[int])
1016 self.assertEqual(repr(E.a), '<E.a: typing.List[int]>')
1017 self.assertEqual(repr(E.b), '<E.b: list[int]>')
1023 def test_nested_classes_in_enum_are_members(self):
1027 with self.assertWarnsRegex(DeprecationWarning, 'will not become a member'):
1034 self.assertTrue(isinstance(Outer.Inner, Outer))
1035 self.assertEqual(Outer.a.value, 1)
1036 self.assertEqual(Outer.Inner.value.foo.value, 10)
1037 self.assertEqual(
1041 self.assertEqual(
1050 def test_nested_classes_in_enum_are_not_members(self):
1058 self.assertTrue(isinstance(Outer.Inner, type))
1059 self.assertEqual(Outer.a.value, 1)
1060 self.assertEqual(Outer.Inner.foo.value, 10)
1061 self.assertEqual(
1065 self.assertEqual(
1070 def test_nested_classes_in_enum_with_nonmember(self):
1078 self.assertTrue(isinstance(Outer.Inner, type))
1079 self.assertEqual(Outer.a.value, 1)
1080 self.assertEqual(Outer.Inner.foo.value, 10)
1081 self.assertEqual(
1085 self.assertEqual(
1090 def test_enum_of_types_with_nonmember(self):
1096 self.assertEqual(MyTypes.i.value, int)
1097 self.assertTrue(MyTypes.f is float)
1098 self.assertEqual(MyTypes.s.value, str)
1106 self.assertEqual(MyTypes2.a.value, Foo)
1107 self.assertTrue(MyTypes2.b is Bar)
1112 self.assertTrue(SpamEnum.spam is SpamEnumIsInner)
1114 def test_nested_classes_in_enum_with_member(self):
1123 self.assertTrue(isinstance(Outer.Inner, Outer))
1124 self.assertEqual(Outer.a.value, 1)
1125 self.assertEqual(Outer.Inner.value.foo.value, 10)
1126 self.assertEqual(
1130 self.assertEqual(
1135 def test_enum_with_value_name(self):
1139 self.assertEqual(list(Huh), [Huh.name, Huh.value])
1140 self.assertIs(type(Huh.name), Huh)
1141 self.assertEqual(Huh.name.name, 'name')
1142 self.assertEqual(Huh.name.value, 1)
1144 def test_inherited_data_type(self):
1147 def __repr__(self):
1148 return hex(self)
1154 self.assertEqual(repr(MyEnum.A), '<MyEnum.A: 0x1>')
1157 test_pickle_dump_load(self.assertIs, MyEnum.A)
1158 test_pickle_dump_load(self.assertIs, MyEnum)
1168 self.assertIs(MyOtherEnum._member_type_, SillyInt)
1171 test_pickle_dump_load(self.assertIs, MyOtherEnum.E)
1172 test_pickle_dump_load(self.assertIs, MyOtherEnum)
1184 self.assertIs(MyUnBrokenEnum._member_type_, UnBrokenInt)
1185 self.assertIs(MyUnBrokenEnum(7), MyUnBrokenEnum.G)
1188 test_pickle_dump_load(self.assertIs, MyUnBrokenEnum.I)
1189 test_pickle_dump_load(self.assertIs, MyUnBrokenEnum)
1191 def test_floatenum_fromhex(self):
1193 self.assertIs(FloatStooges.fromhex(h), FloatStooges.MOE)
1195 with self.assertRaises(ValueError):
1198 def test_programmatic_function_type(self):
1201 self.assertEqual(len(lst), len(MinorEnum))
1202 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1203 self.assertEqual(
1209 self.assertEqual(e, i)
1210 self.assertEqual(e.name, month)
1211 self.assertIn(e, MinorEnum)
1212 self.assertIs(type(e), MinorEnum)
1214 def test_programmatic_function_string_with_start(self):
1217 self.assertEqual(len(lst), len(MinorEnum))
1218 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1219 self.assertEqual(
1225 self.assertEqual(int(e.value), i)
1226 self.assertNotEqual(e, i)
1227 self.assertEqual(e.name, month)
1228 self.assertIn(e, MinorEnum)
1229 self.assertIs(type(e), MinorEnum)
1231 def test_programmatic_function_type_with_start(self):
1234 self.assertEqual(len(lst), len(MinorEnum))
1235 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1236 self.assertEqual(
1242 self.assertEqual(e, i)
1243 self.assertEqual(e.name, month)
1244 self.assertIn(e, MinorEnum)
1245 self.assertIs(type(e), MinorEnum)
1247 def test_programmatic_function_string_list_with_start(self):
1250 self.assertEqual(len(lst), len(MinorEnum))
1251 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1252 self.assertEqual(
1258 self.assertEqual(int(e.value), i)
1259 self.assertNotEqual(e, i)
1260 self.assertEqual(e.name, month)
1261 self.assertIn(e, MinorEnum)
1262 self.assertIs(type(e), MinorEnum)
1264 def test_programmatic_function_type_from_subclass(self):
1267 self.assertEqual(len(lst), len(MinorEnum))
1268 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1269 self.assertEqual(
1275 self.assertEqual(e, i)
1276 self.assertEqual(e.name, month)
1277 self.assertIn(e, MinorEnum)
1278 self.assertIs(type(e), MinorEnum)
1280 def test_programmatic_function_type_from_subclass_with_start(self):
1283 self.assertEqual(len(lst), len(MinorEnum))
1284 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1285 self.assertEqual(
1291 self.assertEqual(e, i)
1292 self.assertEqual(e.name, month)
1293 self.assertIn(e, MinorEnum)
1294 self.assertIs(type(e), MinorEnum)
1296 def test_intenum_from_bytes(self):
1297 self.assertIs(IntStooges.from_bytes(b'\x00\x03', 'big'), IntStooges.MOE)
1298 with self.assertRaises(ValueError):
1301 def test_reserved_sunder_error(self):
1302 with self.assertRaisesRegex(
1309 def test_too_many_data_types(self):
1310 with self.assertRaisesRegex(TypeError, 'too many data types'):
1315 def hello(self):
1316 return 'hello, %s' % self
1318 def repr(self):
1319 return hex(self)
1320 with self.assertRaisesRegex(TypeError, 'too many data types'):
1324 def test_pickle_enum(self):
1327 test_pickle_dump_load(self.assertIs, Stooges.CURLY)
1328 test_pickle_dump_load(self.assertIs, Stooges)
1330 def test_pickle_int(self):
1333 test_pickle_dump_load(self.assertIs, IntStooges.CURLY)
1334 test_pickle_dump_load(self.assertIs, IntStooges)
1336 def test_pickle_float(self):
1339 test_pickle_dump_load(self.assertIs, FloatStooges.CURLY)
1340 test_pickle_dump_load(self.assertIs, FloatStooges)
1342 def test_pickle_enum_function(self):
1345 test_pickle_dump_load(self.assertIs, Answer.him)
1346 test_pickle_dump_load(self.assertIs, Answer)
1348 def test_pickle_enum_function_with_module(self):
1351 test_pickle_dump_load(self.assertIs, Question.who)
1352 test_pickle_dump_load(self.assertIs, Question)
1354 def test_pickle_nested_class(self):
1360 self.__class__.NestedEnum = NestedEnum
1361 self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
1362 test_pickle_dump_load(self.assertIs, self.NestedEnum.twigs)
1364 def test_pickle_by_name(self):
1370 self.assertEqual(ReplaceGlobalInt.TWO.__reduce_ex__(proto), 'TWO')
1372 def test_pickle_explodes(self):
1378 test_pickle_exception(self.assertRaises, TypeError, BadPickle.dill)
1379 test_pickle_exception(self.assertRaises, PicklingError, BadPickle)
1381 def test_string_enum(self):
1386 self.assertEqual(SkillLevel.apprentice, 'knock, knock!')
1388 def test_getattr_getitem(self):
1394 self.assertIs(Period(2), Period.noon)
1395 self.assertIs(getattr(Period, 'night'), Period.night)
1396 self.assertIs(Period['morning'], Period.morning)
1398 def test_getattr_dunder(self):
1399 Season = self.Season
1400 self.assertTrue(getattr(Season, '__eq__'))
1402 def test_iteration_order(self):
1408 self.assertEqual(
1413 def test_subclassing(self):
1416 self.assertEqual(Name.BDFL, 'Guido van Rossum')
1417 self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
1418 self.assertIs(Name.BDFL, getattr(Name, 'BDFL'))
1419 test_pickle_dump_load(self.assertIs, Name.BDFL)
1421 def test_extending(self):
1427 with self.assertRaises(TypeError):
1433 with self.assertRaisesRegex(TypeError, "<enum .EvenMoreColor.> cannot extend <enum .Color.>"):
1437 with self.assertRaisesRegex(TypeError, "<enum .Foo.> cannot extend <enum .Color.>"):
1440 def test_exclude_methods(self):
1444 def really(self):
1445 return 'no, not %s' % self.value
1446 self.assertIsNot(type(whatever.really), whatever)
1447 self.assertEqual(whatever.this.really(), 'no, not that')
1449 def test_wrong_inheritance_order(self):
1450 with self.assertRaises(TypeError):
1454 def test_intenum_transitivity(self):
1463 self.assertEqual(number.one, numero.uno)
1464 self.assertEqual(number.two, numero.dos)
1465 self.assertEqual(number.three, numero.tres)
1467 def test_wrong_enum_in_call(self):
1474 self.assertRaises(ValueError, Monochrome, Gender.male)
1476 def test_wrong_enum_in_mixed_call(self):
1483 self.assertRaises(ValueError, Monochrome, Gender.male)
1485 def test_mixed_enum_in_call_1(self):
1492 self.assertIs(Monochrome(Gender.female), Monochrome.white)
1494 def test_mixed_enum_in_call_2(self):
1501 self.assertIs(Monochrome(Gender.male), Monochrome.black)
1503 def test_flufl_enum(self):
1505 def __int__(self):
1506 return int(self.value)
1511 self.assertEqual(int(MailManOptions.option1), 1)
1513 def test_introspection(self):
1517 self.assertIs(Number.one._member_type_, int)
1518 self.assertIs(Number._member_type_, int)
1523 self.assertIs(String.yarn._member_type_, str)
1524 self.assertIs(String._member_type_, str)
1528 self.assertIs(Plain.vanilla._member_type_, object)
1529 self.assertIs(Plain._member_type_, object)
1531 def test_no_such_enum_member(self):
1536 with self.assertRaises(ValueError):
1538 with self.assertRaises(KeyError):
1543 def test_multiple_mixin_mro(self):
1580 def test_subclasses_with_getnewargs(self):
1588 self = int.__new__(cls, *args)
1589 self._intname = name
1590 self._args = _args
1591 return self
1592 def __getnewargs__(self):
1593 return self._args
1595 def __name__(self):
1596 return self._intname
1597 def __repr__(self):
1600 type(self).__name__,
1601 self.__name__,
1602 int.__repr__(self),
1604 def __str__(self):
1609 return base.__repr__(self)
1610 return base_str(self)
1613 def __add__(self, other):
1614 temp = int(self) + int( other)
1615 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
1617 '({0} + {1})'.format(self.__name__, other.__name__),
1629 self.assertIs(NEI.__new__, Enum.__new__)
1630 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
1634 self.assertEqual(NI5, 5)
1635 test_pickle_dump_load(self.assertEqual, NI5, 5)
1636 self.assertEqual(NEI.y.value, 2)
1637 test_pickle_dump_load(self.assertIs, NEI.y)
1638 test_pickle_dump_load(self.assertIs, NEI)
1640 def test_subclasses_with_getnewargs_ex(self):
1648 self = int.__new__(cls, *args)
1649 self._intname = name
1650 self._args = _args
1651 return self
1652 def __getnewargs_ex__(self):
1653 return self._args, {}
1655 def __name__(self):
1656 return self._intname
1657 def __repr__(self):
1660 type(self).__name__,
1661 self.__name__,
1662 int.__repr__(self),
1664 def __str__(self):
1669 return base.__repr__(self)
1670 return base_str(self)
1673 def __add__(self, other):
1674 temp = int(self) + int( other)
1675 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
1677 '({0} + {1})'.format(self.__name__, other.__name__),
1689 self.assertIs(NEI.__new__, Enum.__new__)
1690 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
1694 self.assertEqual(NI5, 5)
1695 test_pickle_dump_load(self.assertEqual, NI5, 5)
1696 self.assertEqual(NEI.y.value, 2)
1697 test_pickle_dump_load(self.assertIs, NEI.y)
1698 test_pickle_dump_load(self.assertIs, NEI)
1700 def test_subclasses_with_reduce(self):
1708 self = int.__new__(cls, *args)
1709 self._intname = name
1710 self._args = _args
1711 return self
1712 def __reduce__(self):
1713 return self.__class__, self._args
1715 def __name__(self):
1716 return self._intname
1717 def __repr__(self):
1720 type(self).__name__,
1721 self.__name__,
1722 int.__repr__(self),
1724 def __str__(self):
1729 return base.__repr__(self)
1730 return base_str(self)
1733 def __add__(self, other):
1734 temp = int(self) + int( other)
1735 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
1737 '({0} + {1})'.format(self.__name__, other.__name__),
1749 self.assertIs(NEI.__new__, Enum.__new__)
1750 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
1754 self.assertEqual(NI5, 5)
1755 test_pickle_dump_load(self.assertEqual, NI5, 5)
1756 self.assertEqual(NEI.y.value, 2)
1757 test_pickle_dump_load(self.assertIs, NEI.y)
1758 test_pickle_dump_load(self.assertIs, NEI)
1760 def test_subclasses_with_reduce_ex(self):
1768 self = int.__new__(cls, *args)
1769 self._intname = name
1770 self._args = _args
1771 return self
1772 def __reduce_ex__(self, proto):
1773 return self.__class__, self._args
1775 def __name__(self):
1776 return self._intname
1777 def __repr__(self):
1780 type(self).__name__,
1781 self.__name__,
1782 int.__repr__(self),
1784 def __str__(self):
1789 return base.__repr__(self)
1790 return base_str(self)
1793 def __add__(self, other):
1794 temp = int(self) + int( other)
1795 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
1797 '({0} + {1})'.format(self.__name__, other.__name__),
1808 self.assertIs(NEI.__new__, Enum.__new__)
1809 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
1813 self.assertEqual(NI5, 5)
1814 test_pickle_dump_load(self.assertEqual, NI5, 5)
1815 self.assertEqual(NEI.y.value, 2)
1816 test_pickle_dump_load(self.assertIs, NEI.y)
1817 test_pickle_dump_load(self.assertIs, NEI)
1819 def test_subclasses_without_direct_pickle_support(self):
1827 self = int.__new__(cls, *args)
1828 self._intname = name
1829 self._args = _args
1830 return self
1832 def __name__(self):
1833 return self._intname
1834 def __repr__(self):
1837 type(self).__name__,
1838 self.__name__,
1839 int.__repr__(self),
1841 def __str__(self):
1846 return base.__repr__(self)
1847 return base_str(self)
1850 def __add__(self, other):
1851 temp = int(self) + int( other)
1852 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
1854 '({0} + {1})'.format(self.__name__, other.__name__),
1864 self.assertIs(NEI.__new__, Enum.__new__)
1865 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
1869 self.assertEqual(NI5, 5)
1870 self.assertEqual(NEI.y.value, 2)
1871 test_pickle_dump_load(self.assertIs, NEI.y)
1872 test_pickle_dump_load(self.assertIs, NEI)
1874 def test_subclasses_with_direct_pickle_support(self):
1882 self = int.__new__(cls, *args)
1883 self._intname = name
1884 self._args = _args
1885 return self
1887 def __name__(self):
1888 return self._intname
1889 def __repr__(self):
1892 type(self).__name__,
1893 self.__name__,
1894 int.__repr__(self),
1896 def __str__(self):
1901 return base.__repr__(self)
1902 return base_str(self)
1905 def __add__(self, other):
1906 temp = int(self) + int( other)
1907 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
1909 '({0} + {1})'.format(self.__name__, other.__name__),
1919 def __reduce_ex__(self, proto):
1920 return getattr, (self.__class__, self._name_)
1922 self.assertIs(NEI.__new__, Enum.__new__)
1923 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
1927 self.assertEqual(NI5, 5)
1928 self.assertEqual(NEI.y.value, 2)
1929 test_pickle_dump_load(self.assertIs, NEI.y)
1930 test_pickle_dump_load(self.assertIs, NEI)
1932 def test_tuple_subclass(self):
1938 self.assertIs(type(SomeTuple.first), SomeTuple)
1939 self.assertIsInstance(SomeTuple.second, tuple)
1940 self.assertEqual(SomeTuple.third, (3, 'for the music'))
1942 test_pickle_dump_load(self.assertIs, SomeTuple.first)
1944 def test_duplicate_values_give_unique_enum_items(self):
1954 def __int__(self):
1955 return int(self._value_)
1956 self.assertEqual(
1960 self.assertEqual(int(AutoNumber.second), 2)
1961 self.assertEqual(AutoNumber.third.value, 3)
1962 self.assertIs(AutoNumber(1), AutoNumber.first)
1964 def test_inherited_new_from_enhanced_enum(self):
1971 def __int__(self):
1972 return int(self._value_)
1977 self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
1978 self.assertEqual(list(map(int, Color)), [1, 2, 3])
1980 def test_inherited_new_from_mixed_enum(self):
1991 self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
1992 self.assertEqual(list(map(int, Color)), [1, 2, 3])
1994 def test_equality(self):
1997 self.assertEqual(ALWAYS_EQ, OrdinaryEnum.a)
1998 self.assertEqual(OrdinaryEnum.a, ALWAYS_EQ)
2000 def test_ordered_mixin(self):
2002 def __ge__(self, other):
2003 if self.__class__ is other.__class__:
2004 return self._value_ >= other._value_
2006 def __gt__(self, other):
2007 if self.__class__ is other.__class__:
2008 return self._value_ > other._value_
2010 def __le__(self, other):
2011 if self.__class__ is other.__class__:
2012 return self._value_ <= other._value_
2014 def __lt__(self, other):
2015 if self.__class__ is other.__class__:
2016 return self._value_ < other._value_
2024 self.assertGreater(Grade.A, Grade.B)
2025 self.assertLessEqual(Grade.F, Grade.C)
2026 self.assertLess(Grade.D, Grade.A)
2027 self.assertGreaterEqual(Grade.B, Grade.B)
2028 self.assertEqual(Grade.B, Grade.B)
2029 self.assertNotEqual(Grade.C, Grade.D)
2031 def test_extending2(self):
2033 def shade(self):
2034 print(self.name)
2039 with self.assertRaises(TypeError):
2045 def test_extending3(self):
2047 def shade(self):
2048 return self.name
2050 def hex(self):
2051 return '%s hexlified!' % self.value
2056 self.assertEqual(MoreColor.magenta.hex(), '5 hexlified!')
2058 def test_subclass_duplicate_name(self):
2060 def test(self):
2064 self.assertIs(type(Test.test), Test)
2066 def test_subclass_duplicate_name_dynamic(self):
2070 def test(self):
2074 self.assertEqual(Test.test.test, 'dynamic')
2075 self.assertEqual(Test.test.value, 1)
2078 def flash(self):
2082 self.assertEqual(Test.flash.flash, 'flashy dynamic')
2083 self.assertEqual(Test.flash.value, 1)
2085 def test_no_duplicates(self):
2087 def __init__(self, *args):
2088 cls = self.__class__
2089 if any(self.value == e.value for e in cls):
2090 a = self.name
2091 e = cls(self.value).name
2100 with self.assertRaises(ValueError):
2107 def test_init(self):
2117 def __init__(self, mass, radius):
2118 self.mass = mass # in kilograms
2119 self.radius = radius # in meters
2121 def surface_gravity(self):
2124 return G * self.mass / (self.radius * self.radius)
2125 self.assertEqual(round(Planet.EARTH.surface_gravity, 2), 9.80)
2126 self.assertEqual(Planet.EARTH.value, (5.976e+24, 6.37814e6))
2128 def test_ignore(self):
2149 self.assertFalse(hasattr(Period, '_ignore_'))
2150 self.assertFalse(hasattr(Period, 'Period'))
2151 self.assertFalse(hasattr(Period, 'i'))
2152 self.assertTrue(isinstance(Period.day_1, timedelta))
2153 self.assertTrue(Period.month_1 is Period.day_30)
2154 self.assertTrue(Period.week_4 is Period.day_28)
2156 def test_nonhash_value(self):
2167 self.assertEqual(list(ColorInAList), [ColorInAList.red, ColorInAList.green, ColorInAList.blue])
2170 self.assertEqual(enum.value, [value])
2171 self.assertIs(ColorInAList([value]), enum)
2173 def test_conflicting_types_resolved_in_new(self):
2186 self.assertEqual(list(LabelledList), [LabelledList.unprocessed, LabelledList.payment_complete])
2187 self.assertEqual(LabelledList.unprocessed, 1)
2188 self.assertEqual(LabelledList(1), LabelledList.unprocessed)
2190 def test_default_missing_no_chained_exception(self):
2198 self.assertTrue(exc.__context__ is None)
2202 def test_missing_override(self):
2219 self.assertIs(Color('three'), Color.blue)
2223 self.assertTrue(exc.__context__ is None)
2229 self.assertTrue(isinstance(exc.__context__, ValueError))
2235 self.assertTrue(isinstance(exc.__context__, ValueError))
2239 def test_missing_exceptions_reset(self):
2248 def __init__(self):
2256 def __init__(self):
2270 self.assertIs(class_1_ref(), None)
2271 self.assertIs(class_2_ref(), None)
2273 def test_multiple_mixin(self):
2281 def __str__(self):
2282 return self._name_.lower()
2284 def behavior(self):
2287 def behavior(self):
2289 def social(self):
2295 self.assertEqual(Color.RED.value, 1)
2296 self.assertEqual(Color.GREEN.value, 2)
2297 self.assertEqual(Color.BLUE.value, 3)
2298 self.assertEqual(Color.MAX, 3)
2299 self.assertEqual(str(Color.BLUE), 'Color.BLUE')
2305 self.assertEqual(Color.RED.value, 1)
2306 self.assertEqual(Color.GREEN.value, 2)
2307 self.assertEqual(Color.BLUE.value, 3)
2308 self.assertEqual(Color.MAX, 3)
2309 self.assertEqual(str(Color.BLUE), 'blue')
2315 self.assertEqual(Color.RED.value, 1)
2316 self.assertEqual(Color.GREEN.value, 2)
2317 self.assertEqual(Color.BLUE.value, 3)
2318 self.assertEqual(Color.MAX, 3)
2319 self.assertEqual(str(Color.BLUE), 'blue')
2325 self.assertEqual(CoolColor.RED.value, 1)
2326 self.assertEqual(CoolColor.GREEN.value, 2)
2327 self.assertEqual(CoolColor.BLUE.value, 3)
2328 self.assertEqual(str(CoolColor.BLUE), 'blue')
2329 self.assertEqual(CoolColor.RED.behavior(), 'booyah')
2335 self.assertEqual(CoolerColor.RED.value, 1)
2336 self.assertEqual(CoolerColor.GREEN.value, 2)
2337 self.assertEqual(CoolerColor.BLUE.value, 3)
2338 self.assertEqual(str(CoolerColor.BLUE), 'blue')
2339 self.assertEqual(CoolerColor.RED.behavior(), 'nuhuh!')
2340 self.assertEqual(CoolerColor.RED.social(), "what's up?")
2346 self.assertEqual(CoolestColor.RED.value, 1)
2347 self.assertEqual(CoolestColor.GREEN.value, 2)
2348 self.assertEqual(CoolestColor.BLUE.value, 3)
2349 self.assertEqual(str(CoolestColor.BLUE), 'blue')
2350 self.assertEqual(CoolestColor.RED.behavior(), 'booyah')
2351 self.assertEqual(CoolestColor.RED.social(), "what's up?")
2357 self.assertEqual(ConfusedColor.RED.value, 1)
2358 self.assertEqual(ConfusedColor.GREEN.value, 2)
2359 self.assertEqual(ConfusedColor.BLUE.value, 3)
2360 self.assertEqual(str(ConfusedColor.BLUE), 'blue')
2361 self.assertEqual(ConfusedColor.RED.behavior(), 'nuhuh!')
2362 self.assertEqual(ConfusedColor.RED.social(), "what's up?")
2368 self.assertEqual(ReformedColor.RED.value, 1)
2369 self.assertEqual(ReformedColor.GREEN.value, 2)
2370 self.assertEqual(ReformedColor.BLUE.value, 3)
2371 self.assertEqual(str(ReformedColor.BLUE), 'blue')
2372 self.assertEqual(ReformedColor.RED.behavior(), 'booyah')
2373 self.assertEqual(ConfusedColor.RED.social(), "what's up?")
2374 self.assertTrue(issubclass(ReformedColor, int))
2376 def test_multiple_inherited_mixin(self):
2390 def test_multiple_mixin_inherited(self):
2396 def __repr__(self):
2397 return hex(self)
2404 self.assertTrue(isinstance(Foo.TEST, MyInt))
2405 self.assertEqual(Foo._member_type_, MyInt)
2406 self.assertEqual(repr(Foo.TEST), "0x1")
2415 self.assertEqual(Fee.TEST, 2)
2417 def test_multiple_mixin_with_common_data_type(self):
2427 def __init__(self, *args):
2428 self._valid = True
2438 def valid(self):
2439 return self._valid
2447 self.assertEqual(list(JobStatus), [JS.ACTIVE, JS.PENDING, JS.TERMINATED])
2448 self.assertEqual(JS.ACTIVE, 'active')
2449 self.assertEqual(JS.ACTIVE.value, 'active')
2450 self.assertIs(JS('Active'), JS.ACTIVE)
2451 self.assertTrue(JS.ACTIVE.valid)
2453 self.assertEqual(list(JobStatus), [JS.ACTIVE, JS.PENDING, JS.TERMINATED])
2454 self.assertEqual(JS.ACTIVE, 'active')
2455 self.assertEqual(JS.ACTIVE.value, 'active')
2456 self.assertIs(JS('Active'), JS.ACTIVE)
2457 self.assertTrue(JS.ACTIVE.valid)
2458 self.assertTrue(isinstance(missing, JS))
2459 self.assertFalse(missing.valid)
2461 def test_empty_globals(self):
2470 def test_strenum(self):
2476 self.assertEqual(GoodStrEnum.one, '1')
2477 self.assertEqual(str(GoodStrEnum.one), '1')
2478 self.assertEqual('{}'.format(GoodStrEnum.one), '1')
2479 self.assertEqual(GoodStrEnum.one, str(GoodStrEnum.one))
2480 self.assertEqual(GoodStrEnum.one, '{}'.format(GoodStrEnum.one))
2481 self.assertEqual(repr(GoodStrEnum.one), "<GoodStrEnum.one: '1'>")
2484 def __str__(self):
2491 self.assertEqual(DumbStrEnum.seven, '7')
2492 self.assertEqual(str(DumbStrEnum.seven), "don't do this")
2495 def hello(self):
2496 print('hello from %s' % (self, ))
2499 self.assertEqual(HelloEnum.eight, '8')
2500 self.assertEqual(HelloEnum.eight, str(HelloEnum.eight))
2503 def goodbye(self):
2507 self.assertEqual(GoodbyeEnum.nine, '9')
2508 self.assertEqual(GoodbyeEnum.nine, str(GoodbyeEnum.nine))
2510 with self.assertRaisesRegex(TypeError, '1 is not a string'):
2514 with self.assertRaisesRegex(TypeError, "2 is not a string"):
2519 with self.assertRaisesRegex(TypeError, '2 is not a string'):
2523 with self.assertRaisesRegex(TypeError, 'encoding must be a string, not %r' % (sys.getdefaultencoding, )):
2527 with self.assertRaisesRegex(TypeError, 'errors must be a string, not 9'):
2532 def test_custom_strenum(self):
2540 self.assertEqual(OkayEnum.one, '1')
2541 self.assertEqual(str(OkayEnum.one), 'OkayEnum.one')
2542 self.assertEqual('{}'.format(OkayEnum.one), 'OkayEnum.one')
2543 self.assertEqual(repr(OkayEnum.one), "<OkayEnum.one: '1'>")
2546 def __str__(self):
2553 self.assertEqual(DumbStrEnum.seven, '7')
2554 self.assertEqual(str(DumbStrEnum.seven), "don't do this")
2557 def hello(self):
2558 print('hello from %s' % (self, ))
2561 self.assertEqual(HelloEnum.eight, '8')
2562 self.assertEqual(str(HelloEnum.eight), 'HelloEnum.eight')
2565 def goodbye(self):
2569 self.assertEqual(GoodbyeEnum.nine, '9')
2570 self.assertEqual(str(GoodbyeEnum.nine), 'GoodbyeEnum.nine')
2582 with self.assertRaisesRegex(TypeError, '.encoding. must be str, not '):
2586 with self.assertRaisesRegex(TypeError, '.errors. must be str, not '):
2591 def test_missing_value_error(self):
2592 with self.assertRaisesRegex(TypeError, "_value_ not set in __new__"):
2608 def __repr__(self):
2609 return "<%s.%s>" % (self.__class__.__name__, self._name_)
2617 def test_private_variable_is_normal_attribute(self):
2621 self.assertEqual(Private._Private__corporal, 'Radar')
2622 self.assertEqual(Private._Private__major_, 'Hoolihan')
2624 def test_member_from_member_access(self):
2630 self.assertIs(warn, Di.NO)
2631 self.assertIs(Di.name, Di['name'])
2632 self.assertEqual(Di.name.name, 'name')
2634 def test_dynamic_members_with_static_methods(self):
2643 def upper(self):
2644 return self.value.upper()
2645 self.assertEqual(list(Foo), [Foo.FOO_CAT, Foo.FOO_HORSE])
2646 self.assertEqual(Foo.FOO_CAT.value, 'aloof')
2647 self.assertEqual(Foo.FOO_HORSE.upper(), 'BIG')
2649 with self.assertRaisesRegex(TypeError, "'FOO_CAT' already defined as 'aloof'"):
2658 def upper(self):
2659 return self.value.upper()
2661 def test_repr_with_dataclass(self):
2670 self.assertTrue(isinstance(Entries.ENTRY1, Foo))
2671 self.assertTrue(Entries._member_type_ is Foo, Entries._member_type_)
2672 self.assertTrue(Entries.ENTRY1.value == Foo(1), Entries.ENTRY1.value)
2673 self.assertEqual(repr(Entries.ENTRY1), '<Entries.ENTRY1: Foo(a=1)>')
2675 def test_repr_with_init_mixin(self):
2677 def __init__(self, a):
2678 self.a = a
2679 def __repr__(self):
2680 return 'Foo(a=%r)' % self._value_
2684 self.assertEqual(repr(Entries.ENTRY1), 'Foo(a=1)')
2686 def test_repr_and_str_with_no_init_mixin(self):
2689 def __repr__(self):
2691 def __str__(self):
2696 self.assertEqual(repr(Entries.ENTRY1), 'Foo')
2697 self.assertEqual(str(Entries.ENTRY1), 'ooF')
2699 def test_value_backup_assign(self):
2706 self.assertEqual(Some.x.value, 1)
2707 self.assertEqual(Some.y.value, 2)
2709 def test_custom_flag_bitwise(self):
2714 self.assertTrue(isinstance(MyIntFlag.ONE | MyIntFlag.TWO, MyIntFlag), MyIntFlag.ONE | MyIntFlag.TWO)
2715 self.assertTrue(isinstance(MyIntFlag.ONE | 2, MyIntFlag))
2717 def test_int_flags_copy(self):
2726 self.assertEqual(copied, flags)
2727 self.assertEqual(deep, flags)
2732 self.assertEqual(copied, flags)
2733 self.assertEqual(deep, flags)
2734 self.assertEqual(copied.value, 1 | 2 | 8)
2736 def test_namedtuple_as_value(self):
2743 self.assertEqual(repr(NTEnum.NONE), "<NTEnum.NONE: TTuple(id=0, a=0, blist=[])>")
2744 self.assertEqual(NTEnum.NONE.value, TTuple(id=0, a=0, blist=[]))
2745 self.assertEqual(
2750 def test_flag_with_custom_new(self):
2754 self = int.__new__(cls, value)
2755 self._value_ = value
2756 return self
2760 self.assertEqual(FlagFromChar._all_bits_, 316912650057057350374175801343)
2761 self.assertEqual(FlagFromChar._flag_mask_, 158456325028528675187087900672)
2762 self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
2763 self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
2769 self = object.__new__(cls)
2770 self._value_ = value
2771 return self
2776 self.assertEqual(FlagFromChar._all_bits_, 316912650057057350374175801343)
2777 self.assertEqual(FlagFromChar._flag_mask_, 158456325028528675187087900674)
2778 self.assertEqual(FlagFromChar.a.value, 158456325028528675187087900672)
2779 self.assertEqual((FlagFromChar.a|FlagFromChar.z).value, 158456325028528675187087900674)
2785 self = int.__new__(cls, value)
2786 self._value_ = value
2787 return self
2791 self.assertEqual(FlagFromChar._all_bits_, 316912650057057350374175801343)
2792 self.assertEqual(FlagFromChar._flag_mask_, 158456325028528675187087900672)
2793 self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
2794 self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
2796 def test_init_exception(self):
2800 def __init__(self, x):
2802 with self.assertRaises(TypeError):
2805 def __init__(self, y):
2806 self.y = y
2807 with self.assertRaises(ValueError):
2810 def __init__(self, y):
2811 self.y = y
2821 def test_same_members(self):
2828 def test_same_members_with_aliases(self):
2836 def test_same_members_wrong_order(self):
2837 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
2844 def test_order_has_extra_members(self):
2845 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
2852 def test_order_has_extra_members_with_aliases(self):
2853 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
2861 def test_enum_has_extra_members(self):
2862 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
2870 def test_enum_has_extra_members_with_aliases(self):
2871 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
2904 def test_or(self):
2905 Perm = self.Perm
2908 self.assertEqual((i | j), Perm(i.value | j.value))
2909 self.assertEqual((i | j).value, i.value | j.value)
2910 self.assertIs(type(i | j), Perm)
2912 self.assertIs(i | i, i)
2913 Open = self.Open
2914 self.assertIs(Open.RO | Open.CE, Open.CE)
2916 def test_and(self):
2917 Perm = self.Perm
2925 self.assertEqual((i & j).value, i.value & j.value)
2926 self.assertIs(type(i & j), Perm)
2928 self.assertIs(i & i, i)
2929 self.assertIs(i & RWX, i)
2930 self.assertIs(RWX & i, i)
2931 Open = self.Open
2932 self.assertIs(Open.RO & Open.CE, Open.RO)
2934 def test_xor(self):
2935 Perm = self.Perm
2938 self.assertEqual((i ^ j).value, i.value ^ j.value)
2939 self.assertIs(type(i ^ j), Perm)
2941 self.assertIs(i ^ Perm(0), i)
2942 self.assertIs(Perm(0) ^ i, i)
2943 Open = self.Open
2944 self.assertIs(Open.RO ^ Open.CE, Open.CE)
2945 self.assertIs(Open.CE ^ Open.CE, Open.RO)
2947 def test_invert(self):
2948 Perm = self.Perm
2955 self.assertIs(type(~i), Perm)
2956 self.assertEqual(~~i, i)
2958 self.assertIs(~~i, i)
2959 Open = self.Open
2960 self.assertIs(Open.WO & ~Open.WO, Open.RO)
2961 self.assertIs((Open.WO|Open.CE) & ~Open.WO, Open.CE)
2963 def test_bool(self):
2964 Perm = self.Perm
2966 self.assertTrue(f)
2967 Open = self.Open
2969 self.assertEqual(bool(f.value), bool(f))
2971 def test_boundary(self):
2972 self.assertIs(enum.Flag._boundary_, STRICT)
2977 self.assertIs(Iron._boundary_, CONFORM)
2983 self.assertIs(Water._boundary_, STRICT)
2989 self.assertIs(Space._boundary_, EJECT)
2996 self.assertRaisesRegex(ValueError, 'invalid value 7', Water, 7)
2998 self.assertIs(Iron(7), Iron.ONE|Iron.TWO)
2999 self.assertIs(Iron(~9), Iron.TWO)
3001 self.assertEqual(Space(7), 7)
3002 self.assertTrue(type(Space(7)) is int)
3004 self.assertEqual(list(Bizarre), [Bizarre.c])
3005 self.assertIs(Bizarre(3), Bizarre.b)
3006 self.assertIs(Bizarre(6), Bizarre.d)
3013 self.assertTrue(SkipFlag.C in (SkipFlag.A|SkipFlag.C))
3014 self.assertRaisesRegex(ValueError, 'SkipFlag.. invalid value 42', SkipFlag, 42)
3021 self.assertTrue(SkipIntFlag.C in (SkipIntFlag.A|SkipIntFlag.C))
3022 self.assertEqual(SkipIntFlag(42).value, 42)
3030 self.assertEqual(str(MethodHint.HiddenText|MethodHint.OnlyMask), 'MethodHint.HiddenText|DigitsOnly|LettersOnly|OnlyMask')
3033 def test_iter(self):
3034 Color = self.Color
3035 Open = self.Open
3036 self.assertEqual(list(Color), [Color.RED, Color.GREEN, Color.BLUE])
3037 self.assertEqual(list(Open), [Open.WO, Open.RW, Open.CE])
3039 def test_programatic_function_string(self):
3042 self.assertEqual(len(lst), len(Perm))
3043 self.assertEqual(len(Perm), 3, Perm)
3044 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3048 self.assertEqual(e.value, v)
3049 self.assertEqual(type(e.value), int)
3050 self.assertEqual(e.name, n)
3051 self.assertIn(e, Perm)
3052 self.assertIs(type(e), Perm)
3054 def test_programatic_function_string_with_start(self):
3057 self.assertEqual(len(lst), len(Perm))
3058 self.assertEqual(len(Perm), 3, Perm)
3059 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3063 self.assertEqual(e.value, v)
3064 self.assertEqual(type(e.value), int)
3065 self.assertEqual(e.name, n)
3066 self.assertIn(e, Perm)
3067 self.assertIs(type(e), Perm)
3069 def test_programatic_function_string_list(self):
3072 self.assertEqual(len(lst), len(Perm))
3073 self.assertEqual(len(Perm), 3, Perm)
3074 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3078 self.assertEqual(e.value, v)
3079 self.assertEqual(type(e.value), int)
3080 self.assertEqual(e.name, n)
3081 self.assertIn(e, Perm)
3082 self.assertIs(type(e), Perm)
3084 def test_programatic_function_iterable(self):
3087 self.assertEqual(len(lst), len(Perm))
3088 self.assertEqual(len(Perm), 3, Perm)
3089 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3093 self.assertEqual(e.value, v)
3094 self.assertEqual(type(e.value), int)
3095 self.assertEqual(e.name, n)
3096 self.assertIn(e, Perm)
3097 self.assertIs(type(e), Perm)
3099 def test_programatic_function_from_dict(self):
3102 self.assertEqual(len(lst), len(Perm))
3103 self.assertEqual(len(Perm), 3, Perm)
3104 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3108 self.assertEqual(e.value, v)
3109 self.assertEqual(type(e.value), int)
3110 self.assertEqual(e.name, n)
3111 self.assertIn(e, Perm)
3112 self.assertIs(type(e), Perm)
3114 def test_pickle(self):
3117 test_pickle_dump_load(self.assertIs, FlagStooges.CURLY)
3118 test_pickle_dump_load(self.assertEqual,
3120 test_pickle_dump_load(self.assertEqual,
3122 test_pickle_dump_load(self.assertIs, FlagStooges)
3124 test_pickle_dump_load(self.assertIs, FlagStoogesWithZero.CURLY)
3125 test_pickle_dump_load(self.assertEqual,
3127 test_pickle_dump_load(self.assertIs, FlagStoogesWithZero.NOFLAG)
3129 test_pickle_dump_load(self.assertIs, IntFlagStooges.CURLY)
3130 test_pickle_dump_load(self.assertEqual,
3132 test_pickle_dump_load(self.assertEqual,
3134 test_pickle_dump_load(self.assertEqual, IntFlagStooges(0))
3135 test_pickle_dump_load(self.assertEqual, IntFlagStooges(0x30))
3136 test_pickle_dump_load(self.assertIs, IntFlagStooges)
3138 test_pickle_dump_load(self.assertIs, IntFlagStoogesWithZero.CURLY)
3139 test_pickle_dump_load(self.assertEqual,
3141 test_pickle_dump_load(self.assertIs, IntFlagStoogesWithZero.NOFLAG)
3147 def test_contains_er(self):
3148 Open = self.Open
3149 Color = self.Color
3150 self.assertFalse(Color.BLACK in Open)
3151 self.assertFalse(Open.RO in Color)
3152 with self.assertRaises(TypeError):
3153 with self.assertWarns(DeprecationWarning):
3155 with self.assertRaises(TypeError):
3156 with self.assertWarns(DeprecationWarning):
3158 with self.assertRaises(TypeError):
3159 with self.assertWarns(DeprecationWarning):
3161 with self.assertRaises(TypeError):
3162 with self.assertWarns(DeprecationWarning):
3169 def test_contains_tf(self):
3170 Open = self.Open
3171 Color = self.Color
3172 self.assertFalse(Color.BLACK in Open)
3173 self.assertFalse(Open.RO in Color)
3174 self.assertFalse('BLACK' in Color)
3175 self.assertFalse('RO' in Open)
3176 self.assertTrue(1 in Color)
3177 self.assertTrue(1 in Open)
3179 def test_member_contains(self):
3180 Perm = self.Perm
3186 self.assertTrue(R in RW)
3187 self.assertTrue(R in RX)
3188 self.assertTrue(R in RWX)
3189 self.assertTrue(W in RW)
3190 self.assertTrue(W in WX)
3191 self.assertTrue(W in RWX)
3192 self.assertTrue(X in RX)
3193 self.assertTrue(X in WX)
3194 self.assertTrue(X in RWX)
3195 self.assertFalse(R in WX)
3196 self.assertFalse(W in RX)
3197 self.assertFalse(X in RW)
3199 def test_member_iter(self):
3200 Color = self.Color
3201 self.assertEqual(list(Color.BLACK), [])
3202 self.assertEqual(list(Color.PURPLE), [Color.RED, Color.BLUE])
3203 self.assertEqual(list(Color.BLUE), [Color.BLUE])
3204 self.assertEqual(list(Color.GREEN), [Color.GREEN])
3205 self.assertEqual(list(Color.WHITE), [Color.RED, Color.GREEN, Color.BLUE])
3206 self.assertEqual(list(Color.WHITE), [Color.RED, Color.GREEN, Color.BLUE])
3208 def test_member_length(self):
3209 self.assertEqual(self.Color.__len__(self.Color.BLACK), 0)
3210 self.assertEqual(self.Color.__len__(self.Color.GREEN), 1)
3211 self.assertEqual(self.Color.__len__(self.Color.PURPLE), 2)
3212 self.assertEqual(self.Color.__len__(self.Color.BLANCO), 3)
3214 def test_number_reset_and_order_cleanup(self):
3223 self.assertEqual(
3226 self.assertIs(Confused.TWO, Confused.DOS)
3227 self.assertEqual(Confused.DOS._value_, 2)
3228 self.assertEqual(Confused.EIGHT._value_, 8)
3229 self.assertEqual(Confused.SIXTEEN._value_, 16)
3231 def test_aliases(self):
3232 Color = self.Color
3233 self.assertEqual(Color(1).name, 'RED')
3234 self.assertEqual(Color['ROJO'].name, 'RED')
3235 self.assertEqual(Color(7).name, 'WHITE')
3236 self.assertEqual(Color['BLANCO'].name, 'WHITE')
3237 self.assertIs(Color.BLANCO, Color.WHITE)
3238 Open = self.Open
3239 self.assertIs(Open['AC'], Open.AC)
3241 def test_auto_number(self):
3247 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
3248 self.assertEqual(Color.red.value, 1)
3249 self.assertEqual(Color.blue.value, 2)
3250 self.assertEqual(Color.green.value, 4)
3252 def test_auto_number_garbage(self):
3253 with self.assertRaisesRegex(TypeError, 'invalid flag value .not an int.'):
3258 def test_duplicate_auto(self):
3263 self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
3265 def test_multiple_mixin(self):
3278 def __str__(self):
3279 return self._name_.lower()
3284 self.assertEqual(Color.RED.value, 1)
3285 self.assertEqual(Color.GREEN.value, 2)
3286 self.assertEqual(Color.BLUE.value, 4)
3287 self.assertEqual(Color.ALL.value, 7)
3288 self.assertEqual(str(Color.BLUE), 'Color.BLUE')
3294 self.assertEqual(Color.RED.value, 1)
3295 self.assertEqual(Color.GREEN.value, 2)
3296 self.assertEqual(Color.BLUE.value, 4)
3297 self.assertEqual(Color.ALL.value, 7)
3298 self.assertEqual(str(Color.BLUE), 'blue')
3304 self.assertEqual(Color.RED.value, 1)
3305 self.assertEqual(Color.GREEN.value, 2)
3306 self.assertEqual(Color.BLUE.value, 4)
3307 self.assertEqual(Color.ALL.value, 7)
3308 self.assertEqual(str(Color.BLUE), 'blue')
3312 def test_unique_composite(self):
3323 def __eq__(self, other):
3324 return self is other
3325 def __hash__(self):
3326 return hash(self._value_)
3344 self.assertFalse(
3347 self.assertEqual(256, len(seen), 'too many composite members created')
3349 def test_init_subclass(self):
3353 self.assertFalse(cls.__dict__.get('_test', False))
3365 self.assertEqual(TheirEnum.__dict__['_test1'], 'MyEnum')
3366 self.assertEqual(WhoseEnum.__dict__['_test1'], 'MyEnum')
3367 self.assertEqual(WhoseEnum.__dict__['_test2'], 'TheirEnum')
3368 self.assertFalse(NoEnum.__dict__.get('_test1', False))
3369 self.assertFalse(NoEnum.__dict__.get('_test2', False))
3379 self.assertEqual(OurEnum.__dict__['_test1'], 'MyEnum')
3380 self.assertFalse(WhereEnum.__dict__.get('_test1', False))
3381 self.assertEqual(WhereEnum.__dict__['_test2'], 'OurEnum')
3382 self.assertFalse(NeverEnum.__dict__.get('_test1', False))
3383 self.assertFalse(NeverEnum.__dict__.get('_test2', False))
3416 def test_type(self):
3417 Perm = self.Perm
3418 self.assertTrue(Perm._member_type_ is int)
3419 Open = self.Open
3421 self.assertTrue(isinstance(f, Perm))
3422 self.assertEqual(f, f.value)
3423 self.assertTrue(isinstance(Perm.W | Perm.X, Perm))
3424 self.assertEqual(Perm.W | Perm.X, 3)
3426 self.assertTrue(isinstance(f, Open))
3427 self.assertEqual(f, f.value)
3428 self.assertTrue(isinstance(Open.WO | Open.RW, Open))
3429 self.assertEqual(Open.WO | Open.RW, 3)
3431 def test_global_repr_keep(self):
3432 self.assertEqual(
3436 self.assertEqual(
3440 self.assertEqual(
3445 def test_global_repr_conform1(self):
3446 self.assertEqual(
3450 self.assertEqual(
3454 self.assertEqual(
3459 def test_global_enum_str(self):
3460 self.assertEqual(str(NoName.ONE & NoName.TWO), 'NoName(0)')
3461 self.assertEqual(str(NoName(0)), 'NoName(0)')
3463 def test_format(self):
3464 Perm = self.Perm
3465 self.assertEqual(format(Perm.R, ''), '4')
3466 self.assertEqual(format(Perm.R | Perm.X, ''), '5')
3472 def __str__(self):
3473 return self._name_
3474 self.assertEqual(format(NewPerm.R, ''), 'R')
3475 self.assertEqual(format(NewPerm.R | Perm.X, ''), 'R|X')
3477 def test_or(self):
3478 Perm = self.Perm
3481 self.assertEqual(i | j, i.value | j.value)
3482 self.assertEqual((i | j).value, i.value | j.value)
3483 self.assertIs(type(i | j), Perm)
3485 self.assertEqual(i | j, i.value | j)
3486 self.assertEqual((i | j).value, i.value | j)
3487 self.assertIs(type(i | j), Perm)
3488 self.assertEqual(j | i, j | i.value)
3489 self.assertEqual((j | i).value, j | i.value)
3490 self.assertIs(type(j | i), Perm)
3492 self.assertIs(i | i, i)
3493 self.assertIs(i | 0, i)
3494 self.assertIs(0 | i, i)
3495 Open = self.Open
3496 self.assertIs(Open.RO | Open.CE, Open.CE)
3498 def test_and(self):
3499 Perm = self.Perm
3507 self.assertEqual(i & j, i.value & j.value, 'i is %r, j is %r' % (i, j))
3508 self.assertEqual((i & j).value, i.value & j.value, 'i is %r, j is %r' % (i, j))
3509 self.assertIs(type(i & j), Perm, 'i is %r, j is %r' % (i, j))
3511 self.assertEqual(i & j, i.value & j)
3512 self.assertEqual((i & j).value, i.value & j)
3513 self.assertIs(type(i & j), Perm)
3514 self.assertEqual(j & i, j & i.value)
3515 self.assertEqual((j & i).value, j & i.value)
3516 self.assertIs(type(j & i), Perm)
3518 self.assertIs(i & i, i)
3519 self.assertIs(i & 7, i)
3520 self.assertIs(7 & i, i)
3521 Open = self.Open
3522 self.assertIs(Open.RO & Open.CE, Open.RO)
3524 def test_xor(self):
3525 Perm = self.Perm
3528 self.assertEqual(i ^ j, i.value ^ j.value)
3529 self.assertEqual((i ^ j).value, i.value ^ j.value)
3530 self.assertIs(type(i ^ j), Perm)
3532 self.assertEqual(i ^ j, i.value ^ j)
3533 self.assertEqual((i ^ j).value, i.value ^ j)
3534 self.assertIs(type(i ^ j), Perm)
3535 self.assertEqual(j ^ i, j ^ i.value)
3536 self.assertEqual((j ^ i).value, j ^ i.value)
3537 self.assertIs(type(j ^ i), Perm)
3539 self.assertIs(i ^ 0, i)
3540 self.assertIs(0 ^ i, i)
3541 Open = self.Open
3542 self.assertIs(Open.RO ^ Open.CE, Open.CE)
3543 self.assertIs(Open.CE ^ Open.CE, Open.RO)
3545 def test_invert(self):
3546 Perm = self.Perm
3553 self.assertEqual(~i, (~i).value)
3554 self.assertIs(type(~i), Perm)
3555 self.assertEqual(~~i, i)
3557 self.assertIs(~~i, i)
3558 Open = self.Open
3559 self.assertIs(Open.WO & ~Open.WO, Open.RO)
3560 self.assertIs((Open.WO|Open.CE) & ~Open.WO, Open.CE)
3562 def test_boundary(self):
3563 self.assertIs(enum.IntFlag._boundary_, KEEP)
3571 self.assertIs(Iron._boundary_, STRICT)
3577 self.assertIs(Water._boundary_, CONFORM)
3583 self.assertIs(Space._boundary_, EJECT)
3590 self.assertRaisesRegex(ValueError, 'invalid value 5', Iron, 5)
3592 self.assertIs(Water(7), Water.ONE|Water.TWO)
3593 self.assertIs(Water(~9), Water.TWO)
3595 self.assertEqual(Space(7), 7)
3596 self.assertTrue(type(Space(7)) is int)
3598 self.assertEqual(list(Bizarre), [Bizarre.c])
3599 self.assertIs(Bizarre(3), Bizarre.b)
3600 self.assertIs(Bizarre(6), Bizarre.d)
3603 self.assertEqual(simple, 3)
3604 self.assertIsInstance(simple, Simple)
3605 self.assertEqual(repr(simple), '<Simple.SINGLE|<Iron.TWO: 2>: 3>')
3606 self.assertEqual(str(simple), '3')
3608 def test_iter(self):
3609 Color = self.Color
3610 Open = self.Open
3611 self.assertEqual(list(Color), [Color.RED, Color.GREEN, Color.BLUE])
3612 self.assertEqual(list(Open), [Open.WO, Open.RW, Open.CE])
3614 def test_programatic_function_string(self):
3617 self.assertEqual(len(lst), len(Perm))
3618 self.assertEqual(len(Perm), 3, Perm)
3619 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3623 self.assertEqual(e.value, v)
3624 self.assertEqual(type(e.value), int)
3625 self.assertEqual(e, v)
3626 self.assertEqual(e.name, n)
3627 self.assertIn(e, Perm)
3628 self.assertIs(type(e), Perm)
3630 def test_programatic_function_string_with_start(self):
3633 self.assertEqual(len(lst), len(Perm))
3634 self.assertEqual(len(Perm), 3, Perm)
3635 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3639 self.assertEqual(e.value, v)
3640 self.assertEqual(type(e.value), int)
3641 self.assertEqual(e, v)
3642 self.assertEqual(e.name, n)
3643 self.assertIn(e, Perm)
3644 self.assertIs(type(e), Perm)
3646 def test_programatic_function_string_list(self):
3649 self.assertEqual(len(lst), len(Perm))
3650 self.assertEqual(len(Perm), 3, Perm)
3651 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3655 self.assertEqual(e.value, v)
3656 self.assertEqual(type(e.value), int)
3657 self.assertEqual(e, v)
3658 self.assertEqual(e.name, n)
3659 self.assertIn(e, Perm)
3660 self.assertIs(type(e), Perm)
3662 def test_programatic_function_iterable(self):
3665 self.assertEqual(len(lst), len(Perm))
3666 self.assertEqual(len(Perm), 3, Perm)
3667 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3671 self.assertEqual(e.value, v)
3672 self.assertEqual(type(e.value), int)
3673 self.assertEqual(e, v)
3674 self.assertEqual(e.name, n)
3675 self.assertIn(e, Perm)
3676 self.assertIs(type(e), Perm)
3678 def test_programatic_function_from_dict(self):
3681 self.assertEqual(len(lst), len(Perm))
3682 self.assertEqual(len(Perm), 3, Perm)
3683 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3687 self.assertEqual(e.value, v)
3688 self.assertEqual(type(e.value), int)
3689 self.assertEqual(e, v)
3690 self.assertEqual(e.name, n)
3691 self.assertIn(e, Perm)
3692 self.assertIs(type(e), Perm)
3695 def test_programatic_function_from_empty_list(self):
3698 self.assertEqual(len(lst), len(Perm))
3699 self.assertEqual(len(Perm), 0, Perm)
3702 self.assertEqual(len(lst), len(Thing))
3703 self.assertEqual(len(Thing), 0, Thing)
3706 def test_programatic_function_from_empty_tuple(self):
3709 self.assertEqual(len(lst), len(Perm))
3710 self.assertEqual(len(Perm), 0, Perm)
3712 self.assertEqual(len(lst), len(Thing))
3713 self.assertEqual(len(Thing), 0, Thing)
3719 def test_contains_er(self):
3720 Open = self.Open
3721 Color = self.Color
3722 self.assertTrue(Color.GREEN in Color)
3723 self.assertTrue(Open.RW in Open)
3724 self.assertFalse(Color.GREEN in Open)
3725 self.assertFalse(Open.RW in Color)
3726 with self.assertRaises(TypeError):
3727 with self.assertWarns(DeprecationWarning):
3729 with self.assertRaises(TypeError):
3730 with self.assertWarns(DeprecationWarning):
3732 with self.assertRaises(TypeError):
3733 with self.assertWarns(DeprecationWarning):
3735 with self.assertRaises(TypeError):
3736 with self.assertWarns(DeprecationWarning):
3743 def test_contains_tf(self):
3744 Open = self.Open
3745 Color = self.Color
3746 self.assertTrue(Color.GREEN in Color)
3747 self.assertTrue(Open.RW in Open)
3748 self.assertTrue(Color.GREEN in Open)
3749 self.assertTrue(Open.RW in Color)
3750 self.assertFalse('GREEN' in Color)
3751 self.assertFalse('RW' in Open)
3752 self.assertTrue(2 in Color)
3753 self.assertTrue(2 in Open)
3755 def test_member_contains(self):
3756 Perm = self.Perm
3762 self.assertTrue(R in RW)
3763 self.assertTrue(R in RX)
3764 self.assertTrue(R in RWX)
3765 self.assertTrue(W in RW)
3766 self.assertTrue(W in WX)
3767 self.assertTrue(W in RWX)
3768 self.assertTrue(X in RX)
3769 self.assertTrue(X in WX)
3770 self.assertTrue(X in RWX)
3771 self.assertFalse(R in WX)
3772 self.assertFalse(W in RX)
3773 self.assertFalse(X in RW)
3774 with self.assertRaises(TypeError):
3775 self.assertFalse('test' in RW)
3777 def test_member_iter(self):
3778 Color = self.Color
3779 self.assertEqual(list(Color.BLACK), [])
3780 self.assertEqual(list(Color.PURPLE), [Color.RED, Color.BLUE])
3781 self.assertEqual(list(Color.BLUE), [Color.BLUE])
3782 self.assertEqual(list(Color.GREEN), [Color.GREEN])
3783 self.assertEqual(list(Color.WHITE), [Color.RED, Color.GREEN, Color.BLUE])
3785 def test_member_length(self):
3786 self.assertEqual(self.Color.__len__(self.Color.BLACK), 0)
3787 self.assertEqual(self.Color.__len__(self.Color.GREEN), 1)
3788 self.assertEqual(self.Color.__len__(self.Color.PURPLE), 2)
3789 self.assertEqual(self.Color.__len__(self.Color.BLANCO), 3)
3791 def test_aliases(self):
3792 Color = self.Color
3793 self.assertEqual(Color(1).name, 'RED')
3794 self.assertEqual(Color['ROJO'].name, 'RED')
3795 self.assertEqual(Color(7).name, 'WHITE')
3796 self.assertEqual(Color['BLANCO'].name, 'WHITE')
3797 self.assertIs(Color.BLANCO, Color.WHITE)
3798 Open = self.Open
3799 self.assertIs(Open['AC'], Open.AC)
3801 def test_bool(self):
3802 Perm = self.Perm
3804 self.assertTrue(f)
3805 Open = self.Open
3807 self.assertEqual(bool(f.value), bool(f))
3810 def test_multiple_mixin(self):
3823 def __str__(self):
3824 return self._name_.lower()
3829 self.assertEqual(Color.RED.value, 1)
3830 self.assertEqual(Color.GREEN.value, 2)
3831 self.assertEqual(Color.BLUE.value, 4)
3832 self.assertEqual(Color.ALL.value, 7)
3833 self.assertEqual(str(Color.BLUE), '4')
3839 self.assertEqual(Color.RED.value, 1)
3840 self.assertEqual(Color.GREEN.value, 2)
3841 self.assertEqual(Color.BLUE.value, 4)
3842 self.assertEqual(Color.ALL.value, 7)
3843 self.assertEqual(str(Color.BLUE), 'blue')
3849 self.assertEqual(Color.RED.value, 1)
3850 self.assertEqual(Color.GREEN.value, 2)
3851 self.assertEqual(Color.BLUE.value, 4)
3852 self.assertEqual(Color.ALL.value, 7)
3853 self.assertEqual(str(Color.BLUE), 'blue')
3857 def test_unique_composite(self):
3868 def __eq__(self, other):
3869 return self is other
3870 def __hash__(self):
3871 return hash(self._value_)
3889 self.assertFalse(
3892 self.assertEqual(256, len(seen), 'too many composite members created')
3897 def test_empty_string(self):
3898 with self.assertRaises(ValueError):
3901 def test_non_latin_character_string(self):
3904 self.assertEqual(item.value, 1)
3906 def test_non_latin_number_string(self):
3909 self.assertEqual(item.value, 1)
3914 def test_unique_clean(self):
3927 def test_unique_dirty(self):
3928 with self.assertRaisesRegex(ValueError, 'tres.*one'):
3934 with self.assertRaisesRegex(
3945 def test_unique_with_name(self):
3961 def test_continuous(self):
3976 with self.assertRaisesRegex(ValueError, 'invalid enum .Missing.: missing values 5, 6, 7, 8, 9, 10, 12'):
3984 with self.assertRaisesRegex(ValueError, 'invalid flag .Incomplete.: missing values 32'):
3992 with self.assertRaisesRegex(ValueError, 'invalid flag .StillIncomplete.: missing values 16'):
4001 def test_composite(self):
4006 self.assertEqual(list(Bizarre), [Bizarre.c])
4007 self.assertEqual(Bizarre.b.value, 3)
4008 self.assertEqual(Bizarre.c.value, 4)
4009 self.assertEqual(Bizarre.d.value, 6)
4010 with self.assertRaisesRegex(
4020 self.assertEqual(enum.show_flag_values(3), [1, 2])
4025 self.assertEqual(list(Bizarre), [Bizarre.c])
4026 self.assertEqual(Bizarre.b.value, 3)
4027 self.assertEqual(Bizarre.c.value, 4)
4028 self.assertEqual(Bizarre.d.value, 6)
4029 with self.assertRaisesRegex(
4037 self.assertEqual(enum.show_flag_values(2), [2])
4039 def test_unique_clean(self):
4052 def test_unique_dirty(self):
4053 with self.assertRaisesRegex(ValueError, 'tres.*one'):
4059 with self.assertRaisesRegex(
4070 def test_unique_with_name(self):
4084 def test_negative_alias(self):
4102 def test_sunder(self):
4103 for name in self.sunder_names + self.private_and_sunder_names:
4104 self.assertTrue(enum._is_sunder(name), '%r is a not sunder name?' % name)
4105 for name in self.dunder_names + self.private_names + self.random_names:
4106 self.assertFalse(enum._is_sunder(name), '%r is a sunder name?' % name)
4108 def test_dunder(self):
4109 for name in self.dunder_names:
4110 self.assertTrue(enum._is_dunder(name), '%r is a not dunder name?' % name)
4111 for name in self.sunder_names + self.private_names + self.private_and_sunder_names + self.random_names:
4112 self.assertFalse(enum._is_dunder(name), '%r is a dunder name?' % name)
4114 def test_is_private(self):
4115 for name in self.private_names + self.private_and_sunder_names:
4116 self.assertTrue(enum._is_private('MyEnum', name), '%r is a not private name?')
4117 for name in self.sunder_names + self.dunder_names + self.random_names:
4118 self.assertFalse(enum._is_private('MyEnum', name), '%r is a private name?')
4120 def test_auto_number(self):
4126 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4127 self.assertEqual(Color.red.value, 1)
4128 self.assertEqual(Color.blue.value, 2)
4129 self.assertEqual(Color.green.value, 3)
4131 def test_auto_name(self):
4139 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4140 self.assertEqual(Color.red.value, 'red')
4141 self.assertEqual(Color.blue.value, 'blue')
4142 self.assertEqual(Color.green.value, 'green')
4144 def test_auto_name_inherit(self):
4153 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4154 self.assertEqual(Color.red.value, 'red')
4155 self.assertEqual(Color.blue.value, 'blue')
4156 self.assertEqual(Color.green.value, 'green')
4162 def test_auto_garbage_ok(self):
4163 with self.assertWarnsRegex(DeprecationWarning, 'will require all values to be sortable'):
4167 self.assertEqual(Color.blue.value, 1)
4173 def test_auto_garbage_corrected_ok(self):
4174 with self.assertWarnsRegex(DeprecationWarning, 'will require all values to be sortable'):
4181 self.assertEqual(list(Color),
4183 self.assertEqual(Color.red.value, 'red')
4184 self.assertEqual(Color.blue.value, 2)
4185 self.assertEqual(Color.green.value, 3)
4186 self.assertEqual(Color.yellow.value, 4)
4192 def test_auto_garbage_fail(self):
4193 with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'):
4202 def test_auto_garbage_corrected_fail(self):
4203 with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'):
4209 def test_auto_order(self):
4210 with self.assertRaises(TypeError):
4218 def test_auto_order_wierd(self):
4226 self.assertEqual(list(Color), [Color.red, Color.blue])
4227 self.assertEqual(Color.red.value, 'pathological case')
4228 self.assertEqual(Color.blue.value, 'blue')
4234 def test_auto_with_aliases(self):
4241 self.assertIs(Color.crimson, Color.red)
4242 self.assertIs(Color.oxford, Color.blue)
4243 self.assertIsNot(Color.green, Color.red)
4244 self.assertIsNot(Color.green, Color.blue)
4246 def test_duplicate_auto(self):
4251 self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
4253 def test_multiple_auto_on_line(self):
4258 self.assertEqual(Huh.ONE.value, 1)
4259 self.assertEqual(Huh.TWO.value, (2, 3))
4260 self.assertEqual(Huh.THREE.value, (4, 5, 6))
4276 self.assertEqual(Hah.MONDAY.value, 'MONDAY')
4277 self.assertEqual(Hah.MONDAY.abbr, 'mon')
4278 self.assertEqual(Hah.TUESDAY.value, 'TUESDAY')
4279 self.assertEqual(Hah.TUESDAY.abbr, 'tue')
4280 self.assertEqual(Hah.WEDNESDAY.value, 'WEDNESDAY')
4281 self.assertEqual(Hah.WEDNESDAY.abbr, 'WED')
4282 self.assertEqual(Hah.THURSDAY.value, 'THURSDAY')
4283 self.assertEqual(Hah.THURSDAY.abbr, 'Thu')
4284 self.assertEqual(Hah.FRIDAY.value, 'FRIDAY')
4285 self.assertEqual(Hah.FRIDAY.abbr, 'fri')
4293 self.assertEqual(Huh.ONE.value, 1)
4294 self.assertEqual(Huh.TWO.value, (2, 2))
4295 self.assertEqual(Huh.THREE.value, (3, 3, 3))
4396 def test_pydoc(self):
4404 helper(self.Color)
4406 self.assertEqual(result, expected_text, result)
4408 def test_inspect_getmembers(self):
4412 ('__members__', self.Color.__members__),
4414 ('YELLOW', self.Color.YELLOW),
4415 ('MAGENTA', self.Color.MAGENTA),
4416 ('CYAN', self.Color.CYAN),
4419 ('__len__', self.Color.__len__),
4420 ('__contains__', self.Color.__contains__),
4422 ('__getitem__', self.Color.__getitem__),
4424 ('__init_subclass__', getattr(self.Color, '__init_subclass__')),
4425 ('__iter__', self.Color.__iter__),
4427 result = dict(inspect.getmembers(self.Color))
4428 self.assertEqual(set(values.keys()), set(result.keys()))
4440 self.fail("result does not equal expected, see print above")
4442 def test_inspect_classify_class_attrs(self):
4449 defining_class=EnumType, object=self.Color.__contains__),
4451 defining_class=self.Color, object='...'),
4453 defining_class=EnumType, object=self.Color.__getitem__),
4455 defining_class=EnumType, object=self.Color.__iter__),
4457 defining_class=object, object=getattr(self.Color, '__init_subclass__')),
4459 defining_class=EnumType, object=self.Color.__len__),
4463 defining_class=self.Color, object=__name__),
4465 defining_class=self.Color, object='Color'),
4467 defining_class=self.Color, object='TestStdLib.Color'),
4469 defining_class=self.Color, object=self.Color.YELLOW),
4471 defining_class=self.Color, object=self.Color.MAGENTA),
4473 defining_class=self.Color, object=self.Color.CYAN),
4485 result = list(inspect.classify_class_attrs(self.Color))
4487 self.assertEqual(
4505 self.fail("result does not equal expected, see print above")
4507 def test_test_simple_enum(self):
4514 def zeroth(self):
4515 return 'zeroed %s' % self.name
4521 def zeroth(self):
4522 return 'zeroed %s' % self.name
4523 self.assertTrue(_test_simple_enum(CheckedColor, SimpleColor) is None)
4525 self.assertRaisesRegex(
4535 self.assertEqual(list(CheckedMissing), [CM.SIXTY_FOUR, CM.ONE_TWENTY_EIGHT, CM.TWENTY_FORTY_EIGHT])
4544 self.assertEqual(list(CheckedMissing), [M.SIXTY_FOUR, M.ONE_TWENTY_EIGHT, M.TWENTY_FORTY_EIGHT])
4551 def test__all__(self):
4552 support.check__all__(self, enum, not_exported={'bin', 'show_flag_values'})
4554 def test_doc_1(self):
4557 self.assertEqual(Single.__doc__, None)
4559 def test_doc_2(self):
4563 self.assertEqual(Double.__doc__, None)
4565 def test_doc_3(self):
4570 self.assertEqual(Triple.__doc__, None)
4572 def test_doc_4(self):
4578 self.assertEqual(Quadruple.__doc__, None)
4612 def __init__(self, module):
4613 self.__dict__.update(module.__dict__)
4616 def tearDown(self):
4631 def test_convert_value_lookup_priority(self):
4639 self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
4641 def test_convert_int(self):
4647 self.assertEqual(test_type.CONVERT_TEST_NAME_F,
4649 self.assertEqual(test_type.CONVERT_TEST_NAME_B, 5)
4650 self.assertEqual(test_type.CONVERT_TEST_NAME_C, 5)
4651 self.assertEqual(test_type.CONVERT_TEST_NAME_D, 5)
4652 self.assertEqual(test_type.CONVERT_TEST_NAME_E, 5)
4662 self.assertEqual(
4669 def test_convert_uncomparable(self):
4675 self.assertEqual(
4680 def test_convert_complex(self):
4686 self.assertEqual(
4691 def test_convert_str(self):
4698 self.assertEqual(test_type.CONVERT_STR_TEST_1, 'hello')
4699 self.assertEqual(test_type.CONVERT_STR_TEST_2, 'goodbye')
4704 self.assertEqual(
4709 self.assertEqual(repr(test_type.CONVERT_STR_TEST_1), '%s.CONVERT_STR_TEST_1' % SHORT_MODULE)
4710 self.assertEqual(str(test_type.CONVERT_STR_TEST_2), 'goodbye')
4711 self.assertEqual(format(test_type.CONVERT_STR_TEST_1), 'hello')
4713 def test_convert_raise(self):
4714 with self.assertRaises(AttributeError):
4720 def test_convert_repr_and_str(self):
4726 self.assertEqual(repr(test_type.CONVERT_STRING_TEST_NAME_A), '%s.CONVERT_STRING_TEST_NAME_A' % SHORT_MODULE)
4727 self.assertEqual(str(test_type.CONVERT_STRING_TEST_NAME_A), '5')
4728 self.assertEqual(format(test_type.CONVERT_STRING_TEST_NAME_A), '5')