com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/test/test_enum.py

@@ -1,2618 +0,0 @@
-import enum
-import inspect
-import pydoc
-import unittest
-from collections import OrderedDict
-from enum import Enum, IntEnum, EnumMeta, Flag, IntFlag, unique, auto
-from io import StringIO
-from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
-from test import support
-try:
-    import threading
-except ImportError:
-    threading = None
-
-
-# for pickle tests
-try:
-    class Stooges(Enum):
-        LARRY = 1
-        CURLY = 2
-        MOE = 3
-except Exception as exc:
-    Stooges = exc
-
-try:
-    class IntStooges(int, Enum):
-        LARRY = 1
-        CURLY = 2
-        MOE = 3
-except Exception as exc:
-    IntStooges = exc
-
-try:
-    class FloatStooges(float, Enum):
-        LARRY = 1.39
-        CURLY = 2.72
-        MOE = 3.142596
-except Exception as exc:
-    FloatStooges = exc
-
-try:
-    class FlagStooges(Flag):
-        LARRY = 1
-        CURLY = 2
-        MOE = 3
-except Exception as exc:
-    FlagStooges = exc
-
-# for pickle test and subclass tests
-try:
-    class StrEnum(str, Enum):
-        'accepts only string values'
-    class Name(StrEnum):
-        BDFL = 'Guido van Rossum'
-        FLUFL = 'Barry Warsaw'
-except Exception as exc:
-    Name = exc
-
-try:
-    Question = Enum('Question', 'who what when where why', module=__name__)
-except Exception as exc:
-    Question = exc
-
-try:
-    Answer = Enum('Answer', 'him this then there because')
-except Exception as exc:
-    Answer = exc
-
-try:
-    Theory = Enum('Theory', 'rule law supposition', qualname='spanish_inquisition')
-except Exception as exc:
-    Theory = exc
-
-# for doctests
-try:
-    class Fruit(Enum):
-        TOMATO = 1
-        BANANA = 2
-        CHERRY = 3
-except Exception:
-    pass
-
-def test_pickle_dump_load(assertion, source, target=None):
-    if target is None:
-        target = source
-    for protocol in range(HIGHEST_PROTOCOL + 1):
-        assertion(loads(dumps(source, protocol=protocol)), target)
-
-def test_pickle_exception(assertion, exception, obj):
-    for protocol in range(HIGHEST_PROTOCOL + 1):
-        with assertion(exception):
-            dumps(obj, protocol=protocol)
-
-class TestHelpers(unittest.TestCase):
-    # _is_descriptor, _is_sunder, _is_dunder
-
-    def test_is_descriptor(self):
-        class foo:
-            pass
-        for attr in ('__get__','__set__','__delete__'):
-            obj = foo()
-            self.assertFalse(enum._is_descriptor(obj))
-            setattr(obj, attr, 1)
-            self.assertTrue(enum._is_descriptor(obj))
-
-    def test_is_sunder(self):
-        for s in ('_a_', '_aa_'):
-            self.assertTrue(enum._is_sunder(s))
-
-        for s in ('a', 'a_', '_a', '__a', 'a__', '__a__', '_a__', '__a_', '_',
-                '__', '___', '____', '_____',):
-            self.assertFalse(enum._is_sunder(s))
-
-    def test_is_dunder(self):
-        for s in ('__a__', '__aa__'):
-            self.assertTrue(enum._is_dunder(s))
-        for s in ('a', 'a_', '_a', '__a', 'a__', '_a_', '_a__', '__a_', '_',
-                '__', '___', '____', '_____',):
-            self.assertFalse(enum._is_dunder(s))
-
-# tests
-
-class TestEnum(unittest.TestCase):
-
-    def setUp(self):
-        class Season(Enum):
-            SPRING = 1
-            SUMMER = 2
-            AUTUMN = 3
-            WINTER = 4
-        self.Season = Season
-
-        class Konstants(float, Enum):
-            E = 2.7182818
-            PI = 3.1415926
-            TAU = 2 * PI
-        self.Konstants = Konstants
-
-        class Grades(IntEnum):
-            A = 5
-            B = 4
-            C = 3
-            D = 2
-            F = 0
-        self.Grades = Grades
-
-        class Directional(str, Enum):
-            EAST = 'east'
-            WEST = 'west'
-            NORTH = 'north'
-            SOUTH = 'south'
-        self.Directional = Directional
-
-        from datetime import date
-        class Holiday(date, Enum):
-            NEW_YEAR = 2013, 1, 1
-            IDES_OF_MARCH = 2013, 3, 15
-        self.Holiday = Holiday
-
-    def test_dir_on_class(self):
-        Season = self.Season
-        self.assertEqual(
-            set(dir(Season)),
-            set(['__class__', '__doc__', '__members__', '__module__',
-                'SPRING', 'SUMMER', 'AUTUMN', 'WINTER']),
-            )
-
-    def test_dir_on_item(self):
-        Season = self.Season
-        self.assertEqual(
-            set(dir(Season.WINTER)),
-            set(['__class__', '__doc__', '__module__', 'name', 'value']),
-            )
-
-    def test_dir_with_added_behavior(self):
-        class Test(Enum):
-            this = 'that'
-            these = 'those'
-            def wowser(self):
-                return ("Wowser! I'm %s!" % self.name)
-        self.assertEqual(
-                set(dir(Test)),
-                set(['__class__', '__doc__', '__members__', '__module__', 'this', 'these']),
-                )
-        self.assertEqual(
-                set(dir(Test.this)),
-                set(['__class__', '__doc__', '__module__', 'name', 'value', 'wowser']),
-                )
-
-    def test_dir_on_sub_with_behavior_on_super(self):
-        # see issue22506
-        class SuperEnum(Enum):
-            def invisible(self):
-                return "did you see me?"
-        class SubEnum(SuperEnum):
-            sample = 5
-        self.assertEqual(
-                set(dir(SubEnum.sample)),
-                set(['__class__', '__doc__', '__module__', 'name', 'value', 'invisible']),
-                )
-
-    def test_enum_in_enum_out(self):
-        Season = self.Season
-        self.assertIs(Season(Season.WINTER), Season.WINTER)
-
-    def test_enum_value(self):
-        Season = self.Season
-        self.assertEqual(Season.SPRING.value, 1)
-
-    def test_intenum_value(self):
-        self.assertEqual(IntStooges.CURLY.value, 2)
-
-    def test_enum(self):
-        Season = self.Season
-        lst = list(Season)
-        self.assertEqual(len(lst), len(Season))
-        self.assertEqual(len(Season), 4, Season)
-        self.assertEqual(
-            [Season.SPRING, Season.SUMMER, Season.AUTUMN, Season.WINTER], lst)
-
-        for i, season in enumerate('SPRING SUMMER AUTUMN WINTER'.split(), 1):
-            e = Season(i)
-            self.assertEqual(e, getattr(Season, season))
-            self.assertEqual(e.value, i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, season)
-            self.assertIn(e, Season)
-            self.assertIs(type(e), Season)
-            self.assertIsInstance(e, Season)
-            self.assertEqual(str(e), 'Season.' + season)
-            self.assertEqual(
-                    repr(e),
-                    '<Season.{0}: {1}>'.format(season, i),
-                    )
-
-    def test_value_name(self):
-        Season = self.Season
-        self.assertEqual(Season.SPRING.name, 'SPRING')
-        self.assertEqual(Season.SPRING.value, 1)
-        with self.assertRaises(AttributeError):
-            Season.SPRING.name = 'invierno'
-        with self.assertRaises(AttributeError):
-            Season.SPRING.value = 2
-
-    def test_changing_member(self):
-        Season = self.Season
-        with self.assertRaises(AttributeError):
-            Season.WINTER = 'really cold'
-
-    def test_attribute_deletion(self):
-        class Season(Enum):
-            SPRING = 1
-            SUMMER = 2
-            AUTUMN = 3
-            WINTER = 4
-
-            def spam(cls):
-                pass
-
-        self.assertTrue(hasattr(Season, 'spam'))
-        del Season.spam
-        self.assertFalse(hasattr(Season, 'spam'))
-
-        with self.assertRaises(AttributeError):
-            del Season.SPRING
-        with self.assertRaises(AttributeError):
-            del Season.DRY
-        with self.assertRaises(AttributeError):
-            del Season.SPRING.name
-
-    def test_bool_of_class(self):
-        class Empty(Enum):
-            pass
-        self.assertTrue(bool(Empty))
-
-    def test_bool_of_member(self):
-        class Count(Enum):
-            zero = 0
-            one = 1
-            two = 2
-        for member in Count:
-            self.assertTrue(bool(member))
-
-    def test_invalid_names(self):
-        with self.assertRaises(ValueError):
-            class Wrong(Enum):
-                mro = 9
-        with self.assertRaises(ValueError):
-            class Wrong(Enum):
-                _create_= 11
-        with self.assertRaises(ValueError):
-            class Wrong(Enum):
-                _get_mixins_ = 9
-        with self.assertRaises(ValueError):
-            class Wrong(Enum):
-                _find_new_ = 1
-        with self.assertRaises(ValueError):
-            class Wrong(Enum):
-                _any_name_ = 9
-
-    def test_bool(self):
-        # plain Enum members are always True
-        class Logic(Enum):
-            true = True
-            false = False
-        self.assertTrue(Logic.true)
-        self.assertTrue(Logic.false)
-        # unless overridden
-        class RealLogic(Enum):
-            true = True
-            false = False
-            def __bool__(self):
-                return bool(self._value_)
-        self.assertTrue(RealLogic.true)
-        self.assertFalse(RealLogic.false)
-        # mixed Enums depend on mixed-in type
-        class IntLogic(int, Enum):
-            true = 1
-            false = 0
-        self.assertTrue(IntLogic.true)
-        self.assertFalse(IntLogic.false)
-
-    def test_contains(self):
-        Season = self.Season
-        self.assertIn(Season.AUTUMN, Season)
-        self.assertNotIn(3, Season)
-
-        val = Season(3)
-        self.assertIn(val, Season)
-
-        class OtherEnum(Enum):
-            one = 1; two = 2
-        self.assertNotIn(OtherEnum.two, Season)
-
-    def test_comparisons(self):
-        Season = self.Season
-        with self.assertRaises(TypeError):
-            Season.SPRING < Season.WINTER
-        with self.assertRaises(TypeError):
-            Season.SPRING > 4
-
-        self.assertNotEqual(Season.SPRING, 1)
-
-        class Part(Enum):
-            SPRING = 1
-            CLIP = 2
-            BARREL = 3
-
-        self.assertNotEqual(Season.SPRING, Part.SPRING)
-        with self.assertRaises(TypeError):
-            Season.SPRING < Part.CLIP
-
-    def test_enum_duplicates(self):
-        class Season(Enum):
-            SPRING = 1
-            SUMMER = 2
-            AUTUMN = FALL = 3
-            WINTER = 4
-            ANOTHER_SPRING = 1
-        lst = list(Season)
-        self.assertEqual(
-            lst,
-            [Season.SPRING, Season.SUMMER,
-             Season.AUTUMN, Season.WINTER,
-            ])
-        self.assertIs(Season.FALL, Season.AUTUMN)
-        self.assertEqual(Season.FALL.value, 3)
-        self.assertEqual(Season.AUTUMN.value, 3)
-        self.assertIs(Season(3), Season.AUTUMN)
-        self.assertIs(Season(1), Season.SPRING)
-        self.assertEqual(Season.FALL.name, 'AUTUMN')
-        self.assertEqual(
-                [k for k,v in Season.__members__.items() if v.name != k],
-                ['FALL', 'ANOTHER_SPRING'],
-                )
-
-    def test_duplicate_name(self):
-        with self.assertRaises(TypeError):
-            class Color(Enum):
-                red = 1
-                green = 2
-                blue = 3
-                red = 4
-
-        with self.assertRaises(TypeError):
-            class Color(Enum):
-                red = 1
-                green = 2
-                blue = 3
-                def red(self):
-                    return 'red'
-
-        with self.assertRaises(TypeError):
-            class Color(Enum):
-                @property
-                def red(self):
-                    return 'redder'
-                red = 1
-                green = 2
-                blue = 3
-
-
-    def test_enum_with_value_name(self):
-        class Huh(Enum):
-            name = 1
-            value = 2
-        self.assertEqual(
-            list(Huh),
-            [Huh.name, Huh.value],
-            )
-        self.assertIs(type(Huh.name), Huh)
-        self.assertEqual(Huh.name.name, 'name')
-        self.assertEqual(Huh.name.value, 1)
-
-    def test_format_enum(self):
-        Season = self.Season
-        self.assertEqual('{}'.format(Season.SPRING),
-                         '{}'.format(str(Season.SPRING)))
-        self.assertEqual( '{:}'.format(Season.SPRING),
-                          '{:}'.format(str(Season.SPRING)))
-        self.assertEqual('{:20}'.format(Season.SPRING),
-                         '{:20}'.format(str(Season.SPRING)))
-        self.assertEqual('{:^20}'.format(Season.SPRING),
-                         '{:^20}'.format(str(Season.SPRING)))
-        self.assertEqual('{:>20}'.format(Season.SPRING),
-                         '{:>20}'.format(str(Season.SPRING)))
-        self.assertEqual('{:<20}'.format(Season.SPRING),
-                         '{:<20}'.format(str(Season.SPRING)))
-
-    def test_format_enum_custom(self):
-        class TestFloat(float, Enum):
-            one = 1.0
-            two = 2.0
-            def __format__(self, spec):
-                return 'TestFloat success!'
-        self.assertEqual('{}'.format(TestFloat.one), 'TestFloat success!')
-
-    def assertFormatIsValue(self, spec, member):
-        self.assertEqual(spec.format(member), spec.format(member.value))
-
-    def test_format_enum_date(self):
-        Holiday = self.Holiday
-        self.assertFormatIsValue('{}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:20}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:^20}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:>20}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:<20}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:%Y %m}', Holiday.IDES_OF_MARCH)
-        self.assertFormatIsValue('{:%Y %m %M:00}', Holiday.IDES_OF_MARCH)
-
-    def test_format_enum_float(self):
-        Konstants = self.Konstants
-        self.assertFormatIsValue('{}', Konstants.TAU)
-        self.assertFormatIsValue('{:}', Konstants.TAU)
-        self.assertFormatIsValue('{:20}', Konstants.TAU)
-        self.assertFormatIsValue('{:^20}', Konstants.TAU)
-        self.assertFormatIsValue('{:>20}', Konstants.TAU)
-        self.assertFormatIsValue('{:<20}', Konstants.TAU)
-        self.assertFormatIsValue('{:n}', Konstants.TAU)
-        self.assertFormatIsValue('{:5.2}', Konstants.TAU)
-        self.assertFormatIsValue('{:f}', Konstants.TAU)
-
-    def test_format_enum_int(self):
-        Grades = self.Grades
-        self.assertFormatIsValue('{}', Grades.C)
-        self.assertFormatIsValue('{:}', Grades.C)
-        self.assertFormatIsValue('{:20}', Grades.C)
-        self.assertFormatIsValue('{:^20}', Grades.C)
-        self.assertFormatIsValue('{:>20}', Grades.C)
-        self.assertFormatIsValue('{:<20}', Grades.C)
-        self.assertFormatIsValue('{:+}', Grades.C)
-        self.assertFormatIsValue('{:08X}', Grades.C)
-        self.assertFormatIsValue('{:b}', Grades.C)
-
-    def test_format_enum_str(self):
-        Directional = self.Directional
-        self.assertFormatIsValue('{}', Directional.WEST)
-        self.assertFormatIsValue('{:}', Directional.WEST)
-        self.assertFormatIsValue('{:20}', Directional.WEST)
-        self.assertFormatIsValue('{:^20}', Directional.WEST)
-        self.assertFormatIsValue('{:>20}', Directional.WEST)
-        self.assertFormatIsValue('{:<20}', Directional.WEST)
-
-    def test_hash(self):
-        Season = self.Season
-        dates = {}
-        dates[Season.WINTER] = '1225'
-        dates[Season.SPRING] = '0315'
-        dates[Season.SUMMER] = '0704'
-        dates[Season.AUTUMN] = '1031'
-        self.assertEqual(dates[Season.AUTUMN], '1031')
-
-    def test_intenum_from_scratch(self):
-        class phy(int, Enum):
-            pi = 3
-            tau = 2 * pi
-        self.assertTrue(phy.pi < phy.tau)
-
-    def test_intenum_inherited(self):
-        class IntEnum(int, Enum):
-            pass
-        class phy(IntEnum):
-            pi = 3
-            tau = 2 * pi
-        self.assertTrue(phy.pi < phy.tau)
-
-    def test_floatenum_from_scratch(self):
-        class phy(float, Enum):
-            pi = 3.1415926
-            tau = 2 * pi
-        self.assertTrue(phy.pi < phy.tau)
-
-    def test_floatenum_inherited(self):
-        class FloatEnum(float, Enum):
-            pass
-        class phy(FloatEnum):
-            pi = 3.1415926
-            tau = 2 * pi
-        self.assertTrue(phy.pi < phy.tau)
-
-    def test_strenum_from_scratch(self):
-        class phy(str, Enum):
-            pi = 'Pi'
-            tau = 'Tau'
-        self.assertTrue(phy.pi < phy.tau)
-
-    def test_strenum_inherited(self):
-        class StrEnum(str, Enum):
-            pass
-        class phy(StrEnum):
-            pi = 'Pi'
-            tau = 'Tau'
-        self.assertTrue(phy.pi < phy.tau)
-
-
-    def test_intenum(self):
-        class WeekDay(IntEnum):
-            SUNDAY = 1
-            MONDAY = 2
-            TUESDAY = 3
-            WEDNESDAY = 4
-            THURSDAY = 5
-            FRIDAY = 6
-            SATURDAY = 7
-
-        self.assertEqual(['a', 'b', 'c'][WeekDay.MONDAY], 'c')
-        self.assertEqual([i for i in range(WeekDay.TUESDAY)], [0, 1, 2])
-
-        lst = list(WeekDay)
-        self.assertEqual(len(lst), len(WeekDay))
-        self.assertEqual(len(WeekDay), 7)
-        target = 'SUNDAY MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY SATURDAY'
-        target = target.split()
-        for i, weekday in enumerate(target, 1):
-            e = WeekDay(i)
-            self.assertEqual(e, i)
-            self.assertEqual(int(e), i)
-            self.assertEqual(e.name, weekday)
-            self.assertIn(e, WeekDay)
-            self.assertEqual(lst.index(e)+1, i)
-            self.assertTrue(0 < e < 8)
-            self.assertIs(type(e), WeekDay)
-            self.assertIsInstance(e, int)
-            self.assertIsInstance(e, Enum)
-
-    def test_intenum_duplicates(self):
-        class WeekDay(IntEnum):
-            SUNDAY = 1
-            MONDAY = 2
-            TUESDAY = TEUSDAY = 3
-            WEDNESDAY = 4
-            THURSDAY = 5
-            FRIDAY = 6
-            SATURDAY = 7
-        self.assertIs(WeekDay.TEUSDAY, WeekDay.TUESDAY)
-        self.assertEqual(WeekDay(3).name, 'TUESDAY')
-        self.assertEqual([k for k,v in WeekDay.__members__.items()
-                if v.name != k], ['TEUSDAY', ])
-
-    def test_intenum_from_bytes(self):
-        self.assertIs(IntStooges.from_bytes(b'\x00\x03', 'big'), IntStooges.MOE)
-        with self.assertRaises(ValueError):
-            IntStooges.from_bytes(b'\x00\x05', 'big')
-
-    def test_floatenum_fromhex(self):
-        h = float.hex(FloatStooges.MOE.value)
-        self.assertIs(FloatStooges.fromhex(h), FloatStooges.MOE)
-        h = float.hex(FloatStooges.MOE.value + 0.01)
-        with self.assertRaises(ValueError):
-            FloatStooges.fromhex(h)
-
-    def test_pickle_enum(self):
-        if isinstance(Stooges, Exception):
-            raise Stooges
-        test_pickle_dump_load(self.assertIs, Stooges.CURLY)
-        test_pickle_dump_load(self.assertIs, Stooges)
-
-    def test_pickle_int(self):
-        if isinstance(IntStooges, Exception):
-            raise IntStooges
-        test_pickle_dump_load(self.assertIs, IntStooges.CURLY)
-        test_pickle_dump_load(self.assertIs, IntStooges)
-
-    def test_pickle_float(self):
-        if isinstance(FloatStooges, Exception):
-            raise FloatStooges
-        test_pickle_dump_load(self.assertIs, FloatStooges.CURLY)
-        test_pickle_dump_load(self.assertIs, FloatStooges)
-
-    def test_pickle_enum_function(self):
-        if isinstance(Answer, Exception):
-            raise Answer
-        test_pickle_dump_load(self.assertIs, Answer.him)
-        test_pickle_dump_load(self.assertIs, Answer)
-
-    def test_pickle_enum_function_with_module(self):
-        if isinstance(Question, Exception):
-            raise Question
-        test_pickle_dump_load(self.assertIs, Question.who)
-        test_pickle_dump_load(self.assertIs, Question)
-
-    def test_enum_function_with_qualname(self):
-        if isinstance(Theory, Exception):
-            raise Theory
-        self.assertEqual(Theory.__qualname__, 'spanish_inquisition')
-
-    def test_class_nested_enum_and_pickle_protocol_four(self):
-        # would normally just have this directly in the class namespace
-        class NestedEnum(Enum):
-            twigs = 'common'
-            shiny = 'rare'
-
-        self.__class__.NestedEnum = NestedEnum
-        self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
-        test_pickle_dump_load(self.assertIs, self.NestedEnum.twigs)
-
-    def test_pickle_by_name(self):
-        class ReplaceGlobalInt(IntEnum):
-            ONE = 1
-            TWO = 2
-        ReplaceGlobalInt.__reduce_ex__ = enum._reduce_ex_by_name
-        for proto in range(HIGHEST_PROTOCOL):
-            self.assertEqual(ReplaceGlobalInt.TWO.__reduce_ex__(proto), 'TWO')
-
-    def test_exploding_pickle(self):
-        BadPickle = Enum(
-                'BadPickle', 'dill sweet bread-n-butter', module=__name__)
-        globals()['BadPickle'] = BadPickle
-        # now break BadPickle to test exception raising
-        enum._make_class_unpicklable(BadPickle)
-        test_pickle_exception(self.assertRaises, TypeError, BadPickle.dill)
-        test_pickle_exception(self.assertRaises, PicklingError, BadPickle)
-
-    def test_string_enum(self):
-        class SkillLevel(str, Enum):
-            master = 'what is the sound of one hand clapping?'
-            journeyman = 'why did the chicken cross the road?'
-            apprentice = 'knock, knock!'
-        self.assertEqual(SkillLevel.apprentice, 'knock, knock!')
-
-    def test_getattr_getitem(self):
-        class Period(Enum):
-            morning = 1
-            noon = 2
-            evening = 3
-            night = 4
-        self.assertIs(Period(2), Period.noon)
-        self.assertIs(getattr(Period, 'night'), Period.night)
-        self.assertIs(Period['morning'], Period.morning)
-
-    def test_getattr_dunder(self):
-        Season = self.Season
-        self.assertTrue(getattr(Season, '__eq__'))
-
-    def test_iteration_order(self):
-        class Season(Enum):
-            SUMMER = 2
-            WINTER = 4
-            AUTUMN = 3
-            SPRING = 1
-        self.assertEqual(
-                list(Season),
-                [Season.SUMMER, Season.WINTER, Season.AUTUMN, Season.SPRING],
-                )
-
-    def test_reversed_iteration_order(self):
-        self.assertEqual(
-                list(reversed(self.Season)),
-                [self.Season.WINTER, self.Season.AUTUMN, self.Season.SUMMER,
-                 self.Season.SPRING]
-                )
-
-    def test_programmatic_function_string(self):
-        SummerMonth = Enum('SummerMonth', 'june july august')
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 1):
-            e = SummerMonth(i)
-            self.assertEqual(int(e.value), i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_string_with_start(self):
-        SummerMonth = Enum('SummerMonth', 'june july august', start=10)
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 10):
-            e = SummerMonth(i)
-            self.assertEqual(int(e.value), i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_string_list(self):
-        SummerMonth = Enum('SummerMonth', ['june', 'july', 'august'])
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 1):
-            e = SummerMonth(i)
-            self.assertEqual(int(e.value), i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_string_list_with_start(self):
-        SummerMonth = Enum('SummerMonth', ['june', 'july', 'august'], start=20)
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 20):
-            e = SummerMonth(i)
-            self.assertEqual(int(e.value), i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_iterable(self):
-        SummerMonth = Enum(
-                'SummerMonth',
-                (('june', 1), ('july', 2), ('august', 3))
-                )
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 1):
-            e = SummerMonth(i)
-            self.assertEqual(int(e.value), i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_from_dict(self):
-        SummerMonth = Enum(
-                'SummerMonth',
-                OrderedDict((('june', 1), ('july', 2), ('august', 3)))
-                )
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 1):
-            e = SummerMonth(i)
-            self.assertEqual(int(e.value), i)
-            self.assertNotEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_type(self):
-        SummerMonth = Enum('SummerMonth', 'june july august', type=int)
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 1):
-            e = SummerMonth(i)
-            self.assertEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_type_with_start(self):
-        SummerMonth = Enum('SummerMonth', 'june july august', type=int, start=30)
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 30):
-            e = SummerMonth(i)
-            self.assertEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_type_from_subclass(self):
-        SummerMonth = IntEnum('SummerMonth', 'june july august')
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 1):
-            e = SummerMonth(i)
-            self.assertEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_programmatic_function_type_from_subclass_with_start(self):
-        SummerMonth = IntEnum('SummerMonth', 'june july august', start=40)
-        lst = list(SummerMonth)
-        self.assertEqual(len(lst), len(SummerMonth))
-        self.assertEqual(len(SummerMonth), 3, SummerMonth)
-        self.assertEqual(
-                [SummerMonth.june, SummerMonth.july, SummerMonth.august],
-                lst,
-                )
-        for i, month in enumerate('june july august'.split(), 40):
-            e = SummerMonth(i)
-            self.assertEqual(e, i)
-            self.assertEqual(e.name, month)
-            self.assertIn(e, SummerMonth)
-            self.assertIs(type(e), SummerMonth)
-
-    def test_subclassing(self):
-        if isinstance(Name, Exception):
-            raise Name
-        self.assertEqual(Name.BDFL, 'Guido van Rossum')
-        self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
-        self.assertIs(Name.BDFL, getattr(Name, 'BDFL'))
-        test_pickle_dump_load(self.assertIs, Name.BDFL)
-
-    def test_extending(self):
-        class Color(Enum):
-            red = 1
-            green = 2
-            blue = 3
-        with self.assertRaises(TypeError):
-            class MoreColor(Color):
-                cyan = 4
-                magenta = 5
-                yellow = 6
-
-    def test_exclude_methods(self):
-        class whatever(Enum):
-            this = 'that'
-            these = 'those'
-            def really(self):
-                return 'no, not %s' % self.value
-        self.assertIsNot(type(whatever.really), whatever)
-        self.assertEqual(whatever.this.really(), 'no, not that')
-
-    def test_wrong_inheritance_order(self):
-        with self.assertRaises(TypeError):
-            class Wrong(Enum, str):
-                NotHere = 'error before this point'
-
-    def test_intenum_transitivity(self):
-        class number(IntEnum):
-            one = 1
-            two = 2
-            three = 3
-        class numero(IntEnum):
-            uno = 1
-            dos = 2
-            tres = 3
-        self.assertEqual(number.one, numero.uno)
-        self.assertEqual(number.two, numero.dos)
-        self.assertEqual(number.three, numero.tres)
-
-    def test_wrong_enum_in_call(self):
-        class Monochrome(Enum):
-            black = 0
-            white = 1
-        class Gender(Enum):
-            male = 0
-            female = 1
-        self.assertRaises(ValueError, Monochrome, Gender.male)
-
-    def test_wrong_enum_in_mixed_call(self):
-        class Monochrome(IntEnum):
-            black = 0
-            white = 1
-        class Gender(Enum):
-            male = 0
-            female = 1
-        self.assertRaises(ValueError, Monochrome, Gender.male)
-
-    def test_mixed_enum_in_call_1(self):
-        class Monochrome(IntEnum):
-            black = 0
-            white = 1
-        class Gender(IntEnum):
-            male = 0
-            female = 1
-        self.assertIs(Monochrome(Gender.female), Monochrome.white)
-
-    def test_mixed_enum_in_call_2(self):
-        class Monochrome(Enum):
-            black = 0
-            white = 1
-        class Gender(IntEnum):
-            male = 0
-            female = 1
-        self.assertIs(Monochrome(Gender.male), Monochrome.black)
-
-    def test_flufl_enum(self):
-        class Fluflnum(Enum):
-            def __int__(self):
-                return int(self.value)
-        class MailManOptions(Fluflnum):
-            option1 = 1
-            option2 = 2
-            option3 = 3
-        self.assertEqual(int(MailManOptions.option1), 1)
-
-    def test_introspection(self):
-        class Number(IntEnum):
-            one = 100
-            two = 200
-        self.assertIs(Number.one._member_type_, int)
-        self.assertIs(Number._member_type_, int)
-        class String(str, Enum):
-            yarn = 'soft'
-            rope = 'rough'
-            wire = 'hard'
-        self.assertIs(String.yarn._member_type_, str)
-        self.assertIs(String._member_type_, str)
-        class Plain(Enum):
-            vanilla = 'white'
-            one = 1
-        self.assertIs(Plain.vanilla._member_type_, object)
-        self.assertIs(Plain._member_type_, object)
-
-    def test_no_such_enum_member(self):
-        class Color(Enum):
-            red = 1
-            green = 2
-            blue = 3
-        with self.assertRaises(ValueError):
-            Color(4)
-        with self.assertRaises(KeyError):
-            Color['chartreuse']
-
-    def test_new_repr(self):
-        class Color(Enum):
-            red = 1
-            green = 2
-            blue = 3
-            def __repr__(self):
-                return "don't you just love shades of %s?" % self.name
-        self.assertEqual(
-                repr(Color.blue),
-                "don't you just love shades of blue?",
-                )
-
-    def test_inherited_repr(self):
-        class MyEnum(Enum):
-            def __repr__(self):
-                return "My name is %s." % self.name
-        class MyIntEnum(int, MyEnum):
-            this = 1
-            that = 2
-            theother = 3
-        self.assertEqual(repr(MyIntEnum.that), "My name is that.")
-
-    def test_multiple_mixin_mro(self):
-        class auto_enum(type(Enum)):
-            def __new__(metacls, cls, bases, classdict):
-                temp = type(classdict)()
-                names = set(classdict._member_names)
-                i = 0
-                for k in classdict._member_names:
-                    v = classdict[k]
-                    if v is Ellipsis:
-                        v = i
-                    else:
-                        i = v
-                    i += 1
-                    temp[k] = v
-                for k, v in classdict.items():
-                    if k not in names:
-                        temp[k] = v
-                return super(auto_enum, metacls).__new__(
-                        metacls, cls, bases, temp)
-
-        class AutoNumberedEnum(Enum, metaclass=auto_enum):
-            pass
-
-        class AutoIntEnum(IntEnum, metaclass=auto_enum):
-            pass
-
-        class TestAutoNumber(AutoNumberedEnum):
-            a = ...
-            b = 3
-            c = ...
-
-        class TestAutoInt(AutoIntEnum):
-            a = ...
-            b = 3
-            c = ...
-
-    def test_subclasses_with_getnewargs(self):
-        class NamedInt(int):
-            __qualname__ = 'NamedInt'       # needed for pickle protocol 4
-            def __new__(cls, *args):
-                _args = args
-                name, *args = args
-                if len(args) == 0:
-                    raise TypeError("name and value must be specified")
-                self = int.__new__(cls, *args)
-                self._intname = name
-                self._args = _args
-                return self
-            def __getnewargs__(self):
-                return self._args
-            @property
-            def __name__(self):
-                return self._intname
-            def __repr__(self):
-                # repr() is updated to include the name and type info
-                return "{}({!r}, {})".format(type(self).__name__,
-                                             self.__name__,
-                                             int.__repr__(self))
-            def __str__(self):
-                # str() is unchanged, even if it relies on the repr() fallback
-                base = int
-                base_str = base.__str__
-                if base_str.__objclass__ is object:
-                    return base.__repr__(self)
-                return base_str(self)
-            # for simplicity, we only define one operator that
-            # propagates expressions
-            def __add__(self, other):
-                temp = int(self) + int( other)
-                if isinstance(self, NamedInt) and isinstance(other, NamedInt):
-                    return NamedInt(
-                        '({0} + {1})'.format(self.__name__, other.__name__),
-                        temp )
-                else:
-                    return temp
-
-        class NEI(NamedInt, Enum):
-            __qualname__ = 'NEI'      # needed for pickle protocol 4
-            x = ('the-x', 1)
-            y = ('the-y', 2)
-
-
-        self.assertIs(NEI.__new__, Enum.__new__)
-        self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
-        globals()['NamedInt'] = NamedInt
-        globals()['NEI'] = NEI
-        NI5 = NamedInt('test', 5)
-        self.assertEqual(NI5, 5)
-        test_pickle_dump_load(self.assertEqual, NI5, 5)
-        self.assertEqual(NEI.y.value, 2)
-        test_pickle_dump_load(self.assertIs, NEI.y)
-        test_pickle_dump_load(self.assertIs, NEI)
-
-    def test_subclasses_with_getnewargs_ex(self):
-        class NamedInt(int):
-            __qualname__ = 'NamedInt'       # needed for pickle protocol 4
-            def __new__(cls, *args):
-                _args = args
-                name, *args = args
-                if len(args) == 0:
-                    raise TypeError("name and value must be specified")
-                self = int.__new__(cls, *args)
-                self._intname = name
-                self._args = _args
-                return self
-            def __getnewargs_ex__(self):
-                return self._args, {}
-            @property
-            def __name__(self):
-                return self._intname
-            def __repr__(self):
-                # repr() is updated to include the name and type info
-                return "{}({!r}, {})".format(type(self).__name__,
-                                             self.__name__,
-                                             int.__repr__(self))
-            def __str__(self):
-                # str() is unchanged, even if it relies on the repr() fallback
-                base = int
-                base_str = base.__str__
-                if base_str.__objclass__ is object:
-                    return base.__repr__(self)
-                return base_str(self)
-            # for simplicity, we only define one operator that
-            # propagates expressions
-            def __add__(self, other):
-                temp = int(self) + int( other)
-                if isinstance(self, NamedInt) and isinstance(other, NamedInt):
-                    return NamedInt(
-                        '({0} + {1})'.format(self.__name__, other.__name__),
-                        temp )
-                else:
-                    return temp
-
-        class NEI(NamedInt, Enum):
-            __qualname__ = 'NEI'      # needed for pickle protocol 4
-            x = ('the-x', 1)
-            y = ('the-y', 2)
-
-
-        self.assertIs(NEI.__new__, Enum.__new__)
-        self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
-        globals()['NamedInt'] = NamedInt
-        globals()['NEI'] = NEI
-        NI5 = NamedInt('test', 5)
-        self.assertEqual(NI5, 5)
-        test_pickle_dump_load(self.assertEqual, NI5, 5)
-        self.assertEqual(NEI.y.value, 2)
-        test_pickle_dump_load(self.assertIs, NEI.y)
-        test_pickle_dump_load(self.assertIs, NEI)
-
-    def test_subclasses_with_reduce(self):
-        class NamedInt(int):
-            __qualname__ = 'NamedInt'       # needed for pickle protocol 4
-            def __new__(cls, *args):
-                _args = args
-                name, *args = args
-                if len(args) == 0:
-                    raise TypeError("name and value must be specified")
-                self = int.__new__(cls, *args)
-                self._intname = name
-                self._args = _args
-                return self
-            def __reduce__(self):
-                return self.__class__, self._args
-            @property
-            def __name__(self):
-                return self._intname
-            def __repr__(self):
-                # repr() is updated to include the name and type info
-                return "{}({!r}, {})".format(type(self).__name__,
-                                             self.__name__,
-                                             int.__repr__(self))
-            def __str__(self):
-                # str() is unchanged, even if it relies on the repr() fallback
-                base = int
-                base_str = base.__str__
-                if base_str.__objclass__ is object:
-                    return base.__repr__(self)
-                return base_str(self)
-            # for simplicity, we only define one operator that
-            # propagates expressions
-            def __add__(self, other):
-                temp = int(self) + int( other)
-                if isinstance(self, NamedInt) and isinstance(other, NamedInt):
-                    return NamedInt(
-                        '({0} + {1})'.format(self.__name__, other.__name__),
-                        temp )
-                else:
-                    return temp
-
-        class NEI(NamedInt, Enum):
-            __qualname__ = 'NEI'      # needed for pickle protocol 4
-            x = ('the-x', 1)
-            y = ('the-y', 2)
-
-
-        self.assertIs(NEI.__new__, Enum.__new__)
-        self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
-        globals()['NamedInt'] = NamedInt
-        globals()['NEI'] = NEI
-        NI5 = NamedInt('test', 5)
-        self.assertEqual(NI5, 5)
-        test_pickle_dump_load(self.assertEqual, NI5, 5)
-        self.assertEqual(NEI.y.value, 2)
-        test_pickle_dump_load(self.assertIs, NEI.y)
-        test_pickle_dump_load(self.assertIs, NEI)
-
-    def test_subclasses_with_reduce_ex(self):
-        class NamedInt(int):
-            __qualname__ = 'NamedInt'       # needed for pickle protocol 4
-            def __new__(cls, *args):
-                _args = args
-                name, *args = args
-                if len(args) == 0:
-                    raise TypeError("name and value must be specified")
-                self = int.__new__(cls, *args)
-                self._intname = name
-                self._args = _args
-                return self
-            def __reduce_ex__(self, proto):
-                return self.__class__, self._args
-            @property
-            def __name__(self):
-                return self._intname
-            def __repr__(self):
-                # repr() is updated to include the name and type info
-                return "{}({!r}, {})".format(type(self).__name__,
-                                             self.__name__,
-                                             int.__repr__(self))
-            def __str__(self):
-                # str() is unchanged, even if it relies on the repr() fallback
-                base = int
-                base_str = base.__str__
-                if base_str.__objclass__ is object:
-                    return base.__repr__(self)
-                return base_str(self)
-            # for simplicity, we only define one operator that
-            # propagates expressions
-            def __add__(self, other):
-                temp = int(self) + int( other)
-                if isinstance(self, NamedInt) and isinstance(other, NamedInt):
-                    return NamedInt(
-                        '({0} + {1})'.format(self.__name__, other.__name__),
-                        temp )
-                else:
-                    return temp
-
-        class NEI(NamedInt, Enum):
-            __qualname__ = 'NEI'      # needed for pickle protocol 4
-            x = ('the-x', 1)
-            y = ('the-y', 2)
-
-
-        self.assertIs(NEI.__new__, Enum.__new__)
-        self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
-        globals()['NamedInt'] = NamedInt
-        globals()['NEI'] = NEI
-        NI5 = NamedInt('test', 5)
-        self.assertEqual(NI5, 5)
-        test_pickle_dump_load(self.assertEqual, NI5, 5)
-        self.assertEqual(NEI.y.value, 2)
-        test_pickle_dump_load(self.assertIs, NEI.y)
-        test_pickle_dump_load(self.assertIs, NEI)
-
-    def test_subclasses_without_direct_pickle_support(self):
-        class NamedInt(int):
-            __qualname__ = 'NamedInt'
-            def __new__(cls, *args):
-                _args = args
-                name, *args = args
-                if len(args) == 0:
-                    raise TypeError("name and value must be specified")
-                self = int.__new__(cls, *args)
-                self._intname = name
-                self._args = _args
-                return self
-            @property
-            def __name__(self):
-                return self._intname
-            def __repr__(self):
-                # repr() is updated to include the name and type info
-                return "{}({!r}, {})".format(type(self).__name__,
-                                             self.__name__,
-                                             int.__repr__(self))
-            def __str__(self):
-                # str() is unchanged, even if it relies on the repr() fallback
-                base = int
-                base_str = base.__str__
-                if base_str.__objclass__ is object:
-                    return base.__repr__(self)
-                return base_str(self)
-            # for simplicity, we only define one operator that
-            # propagates expressions
-            def __add__(self, other):
-                temp = int(self) + int( other)
-                if isinstance(self, NamedInt) and isinstance(other, NamedInt):
-                    return NamedInt(
-                        '({0} + {1})'.format(self.__name__, other.__name__),
-                        temp )
-                else:
-                    return temp
-
-        class NEI(NamedInt, Enum):
-            __qualname__ = 'NEI'
-            x = ('the-x', 1)
-            y = ('the-y', 2)
-
-        self.assertIs(NEI.__new__, Enum.__new__)
-        self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
-        globals()['NamedInt'] = NamedInt
-        globals()['NEI'] = NEI
-        NI5 = NamedInt('test', 5)
-        self.assertEqual(NI5, 5)
-        self.assertEqual(NEI.y.value, 2)
-        test_pickle_exception(self.assertRaises, TypeError, NEI.x)
-        test_pickle_exception(self.assertRaises, PicklingError, NEI)
-
-    def test_subclasses_without_direct_pickle_support_using_name(self):
-        class NamedInt(int):
-            __qualname__ = 'NamedInt'
-            def __new__(cls, *args):
-                _args = args
-                name, *args = args
-                if len(args) == 0:
-                    raise TypeError("name and value must be specified")
-                self = int.__new__(cls, *args)
-                self._intname = name
-                self._args = _args
-                return self
-            @property
-            def __name__(self):
-                return self._intname
-            def __repr__(self):
-                # repr() is updated to include the name and type info
-                return "{}({!r}, {})".format(type(self).__name__,
-                                             self.__name__,
-                                             int.__repr__(self))
-            def __str__(self):
-                # str() is unchanged, even if it relies on the repr() fallback
-                base = int
-                base_str = base.__str__
-                if base_str.__objclass__ is object:
-                    return base.__repr__(self)
-                return base_str(self)
-            # for simplicity, we only define one operator that
-            # propagates expressions
-            def __add__(self, other):
-                temp = int(self) + int( other)
-                if isinstance(self, NamedInt) and isinstance(other, NamedInt):
-                    return NamedInt(
-                        '({0} + {1})'.format(self.__name__, other.__name__),
-                        temp )
-                else:
-                    return temp
-
-        class NEI(NamedInt, Enum):
-            __qualname__ = 'NEI'
-            x = ('the-x', 1)
-            y = ('the-y', 2)
-            def __reduce_ex__(self, proto):
-                return getattr, (self.__class__, self._name_)
-
-        self.assertIs(NEI.__new__, Enum.__new__)
-        self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
-        globals()['NamedInt'] = NamedInt
-        globals()['NEI'] = NEI
-        NI5 = NamedInt('test', 5)
-        self.assertEqual(NI5, 5)
-        self.assertEqual(NEI.y.value, 2)
-        test_pickle_dump_load(self.assertIs, NEI.y)
-        test_pickle_dump_load(self.assertIs, NEI)
-
-    def test_tuple_subclass(self):
-        class SomeTuple(tuple, Enum):
-            __qualname__ = 'SomeTuple'      # needed for pickle protocol 4
-            first = (1, 'for the money')
-            second = (2, 'for the show')
-            third = (3, 'for the music')
-        self.assertIs(type(SomeTuple.first), SomeTuple)
-        self.assertIsInstance(SomeTuple.second, tuple)
-        self.assertEqual(SomeTuple.third, (3, 'for the music'))
-        globals()['SomeTuple'] = SomeTuple
-        test_pickle_dump_load(self.assertIs, SomeTuple.first)
-
-    def test_duplicate_values_give_unique_enum_items(self):
-        class AutoNumber(Enum):
-            first = ()
-            second = ()
-            third = ()
-            def __new__(cls):
-                value = len(cls.__members__) + 1
-                obj = object.__new__(cls)
-                obj._value_ = value
-                return obj
-            def __int__(self):
-                return int(self._value_)
-        self.assertEqual(
-                list(AutoNumber),
-                [AutoNumber.first, AutoNumber.second, AutoNumber.third],
-                )
-        self.assertEqual(int(AutoNumber.second), 2)
-        self.assertEqual(AutoNumber.third.value, 3)
-        self.assertIs(AutoNumber(1), AutoNumber.first)
-
-    def test_inherited_new_from_enhanced_enum(self):
-        class AutoNumber(Enum):
-            def __new__(cls):
-                value = len(cls.__members__) + 1
-                obj = object.__new__(cls)
-                obj._value_ = value
-                return obj
-            def __int__(self):
-                return int(self._value_)
-        class Color(AutoNumber):
-            red = ()
-            green = ()
-            blue = ()
-        self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
-        self.assertEqual(list(map(int, Color)), [1, 2, 3])
-
-    def test_inherited_new_from_mixed_enum(self):
-        class AutoNumber(IntEnum):
-            def __new__(cls):
-                value = len(cls.__members__) + 1
-                obj = int.__new__(cls, value)
-                obj._value_ = value
-                return obj
-        class Color(AutoNumber):
-            red = ()
-            green = ()
-            blue = ()
-        self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
-        self.assertEqual(list(map(int, Color)), [1, 2, 3])
-
-    def test_equality(self):
-        class AlwaysEqual:
-            def __eq__(self, other):
-                return True
-        class OrdinaryEnum(Enum):
-            a = 1
-        self.assertEqual(AlwaysEqual(), OrdinaryEnum.a)
-        self.assertEqual(OrdinaryEnum.a, AlwaysEqual())
-
-    def test_ordered_mixin(self):
-        class OrderedEnum(Enum):
-            def __ge__(self, other):
-                if self.__class__ is other.__class__:
-                    return self._value_ >= other._value_
-                return NotImplemented
-            def __gt__(self, other):
-                if self.__class__ is other.__class__:
-                    return self._value_ > other._value_
-                return NotImplemented
-            def __le__(self, other):
-                if self.__class__ is other.__class__:
-                    return self._value_ <= other._value_
-                return NotImplemented
-            def __lt__(self, other):
-                if self.__class__ is other.__class__:
-                    return self._value_ < other._value_
-                return NotImplemented
-        class Grade(OrderedEnum):
-            A = 5
-            B = 4
-            C = 3
-            D = 2
-            F = 1
-        self.assertGreater(Grade.A, Grade.B)
-        self.assertLessEqual(Grade.F, Grade.C)
-        self.assertLess(Grade.D, Grade.A)
-        self.assertGreaterEqual(Grade.B, Grade.B)
-        self.assertEqual(Grade.B, Grade.B)
-        self.assertNotEqual(Grade.C, Grade.D)
-
-    def test_extending2(self):
-        class Shade(Enum):
-            def shade(self):
-                print(self.name)
-        class Color(Shade):
-            red = 1
-            green = 2
-            blue = 3
-        with self.assertRaises(TypeError):
-            class MoreColor(Color):
-                cyan = 4
-                magenta = 5
-                yellow = 6
-
-    def test_extending3(self):
-        class Shade(Enum):
-            def shade(self):
-                return self.name
-        class Color(Shade):
-            def hex(self):
-                return '%s hexlified!' % self.value
-        class MoreColor(Color):
-            cyan = 4
-            magenta = 5
-            yellow = 6
-        self.assertEqual(MoreColor.magenta.hex(), '5 hexlified!')
-
-
-    def test_no_duplicates(self):
-        class UniqueEnum(Enum):
-            def __init__(self, *args):
-                cls = self.__class__
-                if any(self.value == e.value for e in cls):
-                    a = self.name
-                    e = cls(self.value).name
-                    raise ValueError(
-                            "aliases not allowed in UniqueEnum:  %r --> %r"
-                            % (a, e)
-                            )
-        class Color(UniqueEnum):
-            red = 1
-            green = 2
-            blue = 3
-        with self.assertRaises(ValueError):
-            class Color(UniqueEnum):
-                red = 1
-                green = 2
-                blue = 3
-                grene = 2
-
-    def test_init(self):
-        class Planet(Enum):
-            MERCURY = (3.303e+23, 2.4397e6)
-            VENUS   = (4.869e+24, 6.0518e6)
-            EARTH   = (5.976e+24, 6.37814e6)
-            MARS    = (6.421e+23, 3.3972e6)
-            JUPITER = (1.9e+27,   7.1492e7)
-            SATURN  = (5.688e+26, 6.0268e7)
-            URANUS  = (8.686e+25, 2.5559e7)
-            NEPTUNE = (1.024e+26, 2.4746e7)
-            def __init__(self, mass, radius):
-                self.mass = mass       # in kilograms
-                self.radius = radius   # in meters
-            @property
-            def surface_gravity(self):
-                # universal gravitational constant  (m3 kg-1 s-2)
-                G = 6.67300E-11
-                return G * self.mass / (self.radius * self.radius)
-        self.assertEqual(round(Planet.EARTH.surface_gravity, 2), 9.80)
-        self.assertEqual(Planet.EARTH.value, (5.976e+24, 6.37814e6))
-
-    def test_nonhash_value(self):
-        class AutoNumberInAList(Enum):
-            def __new__(cls):
-                value = [len(cls.__members__) + 1]
-                obj = object.__new__(cls)
-                obj._value_ = value
-                return obj
-        class ColorInAList(AutoNumberInAList):
-            red = ()
-            green = ()
-            blue = ()
-        self.assertEqual(list(ColorInAList), [ColorInAList.red, ColorInAList.green, ColorInAList.blue])
-        for enum, value in zip(ColorInAList, range(3)):
-            value += 1
-            self.assertEqual(enum.value, [value])
-            self.assertIs(ColorInAList([value]), enum)
-
-    def test_conflicting_types_resolved_in_new(self):
-        class LabelledIntEnum(int, Enum):
-            def __new__(cls, *args):
-                value, label = args
-                obj = int.__new__(cls, value)
-                obj.label = label
-                obj._value_ = value
-                return obj
-
-        class LabelledList(LabelledIntEnum):
-            unprocessed = (1, "Unprocessed")
-            payment_complete = (2, "Payment Complete")
-
-        self.assertEqual(list(LabelledList), [LabelledList.unprocessed, LabelledList.payment_complete])
-        self.assertEqual(LabelledList.unprocessed, 1)
-        self.assertEqual(LabelledList(1), LabelledList.unprocessed)
-
-    def test_auto_number(self):
-        class Color(Enum):
-            red = auto()
-            blue = auto()
-            green = auto()
-
-        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
-        self.assertEqual(Color.red.value, 1)
-        self.assertEqual(Color.blue.value, 2)
-        self.assertEqual(Color.green.value, 3)
-
-    def test_auto_name(self):
-        class Color(Enum):
-            def _generate_next_value_(name, start, count, last):
-                return name
-            red = auto()
-            blue = auto()
-            green = auto()
-
-        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
-        self.assertEqual(Color.red.value, 'red')
-        self.assertEqual(Color.blue.value, 'blue')
-        self.assertEqual(Color.green.value, 'green')
-
-    def test_auto_name_inherit(self):
-        class AutoNameEnum(Enum):
-            def _generate_next_value_(name, start, count, last):
-                return name
-        class Color(AutoNameEnum):
-            red = auto()
-            blue = auto()
-            green = auto()
-
-        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
-        self.assertEqual(Color.red.value, 'red')
-        self.assertEqual(Color.blue.value, 'blue')
-        self.assertEqual(Color.green.value, 'green')
-
-    def test_auto_garbage(self):
-        class Color(Enum):
-            red = 'red'
-            blue = auto()
-        self.assertEqual(Color.blue.value, 1)
-
-    def test_auto_garbage_corrected(self):
-        class Color(Enum):
-            red = 'red'
-            blue = 2
-            green = auto()
-
-        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
-        self.assertEqual(Color.red.value, 'red')
-        self.assertEqual(Color.blue.value, 2)
-        self.assertEqual(Color.green.value, 3)
-
-    def test_duplicate_auto(self):
-        class Dupes(Enum):
-            first = primero = auto()
-            second = auto()
-            third = auto()
-        self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
-
-
-class TestOrder(unittest.TestCase):
-
-    def test_same_members(self):
-        class Color(Enum):
-            _order_ = 'red green blue'
-            red = 1
-            green = 2
-            blue = 3
-
-    def test_same_members_with_aliases(self):
-        class Color(Enum):
-            _order_ = 'red green blue'
-            red = 1
-            green = 2
-            blue = 3
-            verde = green
-
-    def test_same_members_wrong_order(self):
-        with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
-            class Color(Enum):
-                _order_ = 'red green blue'
-                red = 1
-                blue = 3
-                green = 2
-
-    def test_order_has_extra_members(self):
-        with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
-            class Color(Enum):
-                _order_ = 'red green blue purple'
-                red = 1
-                green = 2
-                blue = 3
-
-    def test_order_has_extra_members_with_aliases(self):
-        with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
-            class Color(Enum):
-                _order_ = 'red green blue purple'
-                red = 1
-                green = 2
-                blue = 3
-                verde = green
-
-    def test_enum_has_extra_members(self):
-        with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
-            class Color(Enum):
-                _order_ = 'red green blue'
-                red = 1
-                green = 2
-                blue = 3
-                purple = 4
-
-    def test_enum_has_extra_members_with_aliases(self):
-        with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
-            class Color(Enum):
-                _order_ = 'red green blue'
-                red = 1
-                green = 2
-                blue = 3
-                purple = 4
-                verde = green
-
-
-class TestFlag(unittest.TestCase):
-    """Tests of the Flags."""
-
-    class Perm(Flag):
-        R, W, X = 4, 2, 1
-
-    class Open(Flag):
-        RO = 0
-        WO = 1
-        RW = 2
-        AC = 3
-        CE = 1<<19
-
-    def test_str(self):
-        Perm = self.Perm
-        self.assertEqual(str(Perm.R), 'Perm.R')
-        self.assertEqual(str(Perm.W), 'Perm.W')
-        self.assertEqual(str(Perm.X), 'Perm.X')
-        self.assertEqual(str(Perm.R | Perm.W), 'Perm.R|W')
-        self.assertEqual(str(Perm.R | Perm.W | Perm.X), 'Perm.R|W|X')
-        self.assertEqual(str(Perm(0)), 'Perm.0')
-        self.assertEqual(str(~Perm.R), 'Perm.W|X')
-        self.assertEqual(str(~Perm.W), 'Perm.R|X')
-        self.assertEqual(str(~Perm.X), 'Perm.R|W')
-        self.assertEqual(str(~(Perm.R | Perm.W)), 'Perm.X')
-        self.assertEqual(str(~(Perm.R | Perm.W | Perm.X)), 'Perm.0')
-        self.assertEqual(str(Perm(~0)), 'Perm.R|W|X')
-
-        Open = self.Open
-        self.assertEqual(str(Open.RO), 'Open.RO')
-        self.assertEqual(str(Open.WO), 'Open.WO')
-        self.assertEqual(str(Open.AC), 'Open.AC')
-        self.assertEqual(str(Open.RO | Open.CE), 'Open.CE')
-        self.assertEqual(str(Open.WO | Open.CE), 'Open.CE|WO')
-        self.assertEqual(str(~Open.RO), 'Open.CE|AC|RW|WO')
-        self.assertEqual(str(~Open.WO), 'Open.CE|RW')
-        self.assertEqual(str(~Open.AC), 'Open.CE')
-        self.assertEqual(str(~(Open.RO | Open.CE)), 'Open.AC')
-        self.assertEqual(str(~(Open.WO | Open.CE)), 'Open.RW')
-
-    def test_repr(self):
-        Perm = self.Perm
-        self.assertEqual(repr(Perm.R), '<Perm.R: 4>')
-        self.assertEqual(repr(Perm.W), '<Perm.W: 2>')
-        self.assertEqual(repr(Perm.X), '<Perm.X: 1>')
-        self.assertEqual(repr(Perm.R | Perm.W), '<Perm.R|W: 6>')
-        self.assertEqual(repr(Perm.R | Perm.W | Perm.X), '<Perm.R|W|X: 7>')
-        self.assertEqual(repr(Perm(0)), '<Perm.0: 0>')
-        self.assertEqual(repr(~Perm.R), '<Perm.W|X: 3>')
-        self.assertEqual(repr(~Perm.W), '<Perm.R|X: 5>')
-        self.assertEqual(repr(~Perm.X), '<Perm.R|W: 6>')
-        self.assertEqual(repr(~(Perm.R | Perm.W)), '<Perm.X: 1>')
-        self.assertEqual(repr(~(Perm.R | Perm.W | Perm.X)), '<Perm.0: 0>')
-        self.assertEqual(repr(Perm(~0)), '<Perm.R|W|X: 7>')
-
-        Open = self.Open
-        self.assertEqual(repr(Open.RO), '<Open.RO: 0>')
-        self.assertEqual(repr(Open.WO), '<Open.WO: 1>')
-        self.assertEqual(repr(Open.AC), '<Open.AC: 3>')
-        self.assertEqual(repr(Open.RO | Open.CE), '<Open.CE: 524288>')
-        self.assertEqual(repr(Open.WO | Open.CE), '<Open.CE|WO: 524289>')
-        self.assertEqual(repr(~Open.RO), '<Open.CE|AC|RW|WO: 524291>')
-        self.assertEqual(repr(~Open.WO), '<Open.CE|RW: 524290>')
-        self.assertEqual(repr(~Open.AC), '<Open.CE: 524288>')
-        self.assertEqual(repr(~(Open.RO | Open.CE)), '<Open.AC: 3>')
-        self.assertEqual(repr(~(Open.WO | Open.CE)), '<Open.RW: 2>')
-
-    def test_or(self):
-        Perm = self.Perm
-        for i in Perm:
-            for j in Perm:
-                self.assertEqual((i | j), Perm(i.value | j.value))
-                self.assertEqual((i | j).value, i.value | j.value)
-                self.assertIs(type(i | j), Perm)
-        for i in Perm:
-            self.assertIs(i | i, i)
-        Open = self.Open
-        self.assertIs(Open.RO | Open.CE, Open.CE)
-
-    def test_and(self):
-        Perm = self.Perm
-        RW = Perm.R | Perm.W
-        RX = Perm.R | Perm.X
-        WX = Perm.W | Perm.X
-        RWX = Perm.R | Perm.W | Perm.X
-        values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
-        for i in values:
-            for j in values:
-                self.assertEqual((i & j).value, i.value & j.value)
-                self.assertIs(type(i & j), Perm)
-        for i in Perm:
-            self.assertIs(i & i, i)
-            self.assertIs(i & RWX, i)
-            self.assertIs(RWX & i, i)
-        Open = self.Open
-        self.assertIs(Open.RO & Open.CE, Open.RO)
-
-    def test_xor(self):
-        Perm = self.Perm
-        for i in Perm:
-            for j in Perm:
-                self.assertEqual((i ^ j).value, i.value ^ j.value)
-                self.assertIs(type(i ^ j), Perm)
-        for i in Perm:
-            self.assertIs(i ^ Perm(0), i)
-            self.assertIs(Perm(0) ^ i, i)
-        Open = self.Open
-        self.assertIs(Open.RO ^ Open.CE, Open.CE)
-        self.assertIs(Open.CE ^ Open.CE, Open.RO)
-
-    def test_invert(self):
-        Perm = self.Perm
-        RW = Perm.R | Perm.W
-        RX = Perm.R | Perm.X
-        WX = Perm.W | Perm.X
-        RWX = Perm.R | Perm.W | Perm.X
-        values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
-        for i in values:
-            self.assertIs(type(~i), Perm)
-            self.assertEqual(~~i, i)
-        for i in Perm:
-            self.assertIs(~~i, i)
-        Open = self.Open
-        self.assertIs(Open.WO & ~Open.WO, Open.RO)
-        self.assertIs((Open.WO|Open.CE) & ~Open.WO, Open.CE)
-
-    def test_bool(self):
-        Perm = self.Perm
-        for f in Perm:
-            self.assertTrue(f)
-        Open = self.Open
-        for f in Open:
-            self.assertEqual(bool(f.value), bool(f))
-
-    def test_programatic_function_string(self):
-        Perm = Flag('Perm', 'R W X')
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<i
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_string_with_start(self):
-        Perm = Flag('Perm', 'R W X', start=8)
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 8<<i
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_string_list(self):
-        Perm = Flag('Perm', ['R', 'W', 'X'])
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<i
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_iterable(self):
-        Perm = Flag('Perm', (('R', 2), ('W', 8), ('X', 32)))
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<(2*i+1)
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_from_dict(self):
-        Perm = Flag('Perm', OrderedDict((('R', 2), ('W', 8), ('X', 32))))
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<(2*i+1)
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_pickle(self):
-        if isinstance(FlagStooges, Exception):
-            raise FlagStooges
-        test_pickle_dump_load(self.assertIs, FlagStooges.CURLY|FlagStooges.MOE)
-        test_pickle_dump_load(self.assertIs, FlagStooges)
-
-    def test_containment(self):
-        Perm = self.Perm
-        R, W, X = Perm
-        RW = R | W
-        RX = R | X
-        WX = W | X
-        RWX = R | W | X
-        self.assertTrue(R in RW)
-        self.assertTrue(R in RX)
-        self.assertTrue(R in RWX)
-        self.assertTrue(W in RW)
-        self.assertTrue(W in WX)
-        self.assertTrue(W in RWX)
-        self.assertTrue(X in RX)
-        self.assertTrue(X in WX)
-        self.assertTrue(X in RWX)
-        self.assertFalse(R in WX)
-        self.assertFalse(W in RX)
-        self.assertFalse(X in RW)
-
-    def test_auto_number(self):
-        class Color(Flag):
-            red = auto()
-            blue = auto()
-            green = auto()
-
-        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
-        self.assertEqual(Color.red.value, 1)
-        self.assertEqual(Color.blue.value, 2)
-        self.assertEqual(Color.green.value, 4)
-
-    def test_auto_number_garbage(self):
-        with self.assertRaisesRegex(TypeError, 'Invalid Flag value: .not an int.'):
-            class Color(Flag):
-                red = 'not an int'
-                blue = auto()
-
-    def test_cascading_failure(self):
-        class Bizarre(Flag):
-            c = 3
-            d = 4
-            f = 6
-        # Bizarre.c | Bizarre.d
-        self.assertRaisesRegex(ValueError, "5 is not a valid Bizarre", Bizarre, 5)
-        self.assertRaisesRegex(ValueError, "5 is not a valid Bizarre", Bizarre, 5)
-        self.assertRaisesRegex(ValueError, "2 is not a valid Bizarre", Bizarre, 2)
-        self.assertRaisesRegex(ValueError, "2 is not a valid Bizarre", Bizarre, 2)
-        self.assertRaisesRegex(ValueError, "1 is not a valid Bizarre", Bizarre, 1)
-        self.assertRaisesRegex(ValueError, "1 is not a valid Bizarre", Bizarre, 1)
-
-    def test_duplicate_auto(self):
-        class Dupes(Enum):
-            first = primero = auto()
-            second = auto()
-            third = auto()
-        self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
-
-    def test_bizarre(self):
-        class Bizarre(Flag):
-            b = 3
-            c = 4
-            d = 6
-        self.assertEqual(repr(Bizarre(7)), '<Bizarre.d|c|b: 7>')
-
-    @unittest.skipUnless(threading, 'Threading required for this test.')
-    @support.reap_threads
-    def test_unique_composite(self):
-        # override __eq__ to be identity only
-        class TestFlag(Flag):
-            one = auto()
-            two = auto()
-            three = auto()
-            four = auto()
-            five = auto()
-            six = auto()
-            seven = auto()
-            eight = auto()
-            def __eq__(self, other):
-                return self is other
-            def __hash__(self):
-                return hash(self._value_)
-        # have multiple threads competing to complete the composite members
-        seen = set()
-        failed = False
-        def cycle_enum():
-            nonlocal failed
-            try:
-                for i in range(256):
-                    seen.add(TestFlag(i))
-            except Exception:
-                failed = True
-        threads = [
-                threading.Thread(target=cycle_enum)
-                for _ in range(8)
-                ]
-        with support.start_threads(threads):
-            pass
-        # check that only 248 members were created
-        self.assertFalse(
-                failed,
-                'at least one thread failed while creating composite members')
-        self.assertEqual(256, len(seen), 'too many composite members created')
-
-
-class TestIntFlag(unittest.TestCase):
-    """Tests of the IntFlags."""
-
-    class Perm(IntFlag):
-        X = 1 << 0
-        W = 1 << 1
-        R = 1 << 2
-
-    class Open(IntFlag):
-        RO = 0
-        WO = 1
-        RW = 2
-        AC = 3
-        CE = 1<<19
-
-    def test_type(self):
-        Perm = self.Perm
-        Open = self.Open
-        for f in Perm:
-            self.assertTrue(isinstance(f, Perm))
-            self.assertEqual(f, f.value)
-        self.assertTrue(isinstance(Perm.W | Perm.X, Perm))
-        self.assertEqual(Perm.W | Perm.X, 3)
-        for f in Open:
-            self.assertTrue(isinstance(f, Open))
-            self.assertEqual(f, f.value)
-        self.assertTrue(isinstance(Open.WO | Open.RW, Open))
-        self.assertEqual(Open.WO | Open.RW, 3)
-
-
-    def test_str(self):
-        Perm = self.Perm
-        self.assertEqual(str(Perm.R), 'Perm.R')
-        self.assertEqual(str(Perm.W), 'Perm.W')
-        self.assertEqual(str(Perm.X), 'Perm.X')
-        self.assertEqual(str(Perm.R | Perm.W), 'Perm.R|W')
-        self.assertEqual(str(Perm.R | Perm.W | Perm.X), 'Perm.R|W|X')
-        self.assertEqual(str(Perm.R | 8), 'Perm.8|R')
-        self.assertEqual(str(Perm(0)), 'Perm.0')
-        self.assertEqual(str(Perm(8)), 'Perm.8')
-        self.assertEqual(str(~Perm.R), 'Perm.W|X')
-        self.assertEqual(str(~Perm.W), 'Perm.R|X')
-        self.assertEqual(str(~Perm.X), 'Perm.R|W')
-        self.assertEqual(str(~(Perm.R | Perm.W)), 'Perm.X')
-        self.assertEqual(str(~(Perm.R | Perm.W | Perm.X)), 'Perm.-8')
-        self.assertEqual(str(~(Perm.R | 8)), 'Perm.W|X')
-        self.assertEqual(str(Perm(~0)), 'Perm.R|W|X')
-        self.assertEqual(str(Perm(~8)), 'Perm.R|W|X')
-
-        Open = self.Open
-        self.assertEqual(str(Open.RO), 'Open.RO')
-        self.assertEqual(str(Open.WO), 'Open.WO')
-        self.assertEqual(str(Open.AC), 'Open.AC')
-        self.assertEqual(str(Open.RO | Open.CE), 'Open.CE')
-        self.assertEqual(str(Open.WO | Open.CE), 'Open.CE|WO')
-        self.assertEqual(str(Open(4)), 'Open.4')
-        self.assertEqual(str(~Open.RO), 'Open.CE|AC|RW|WO')
-        self.assertEqual(str(~Open.WO), 'Open.CE|RW')
-        self.assertEqual(str(~Open.AC), 'Open.CE')
-        self.assertEqual(str(~(Open.RO | Open.CE)), 'Open.AC|RW|WO')
-        self.assertEqual(str(~(Open.WO | Open.CE)), 'Open.RW')
-        self.assertEqual(str(Open(~4)), 'Open.CE|AC|RW|WO')
-
-    def test_repr(self):
-        Perm = self.Perm
-        self.assertEqual(repr(Perm.R), '<Perm.R: 4>')
-        self.assertEqual(repr(Perm.W), '<Perm.W: 2>')
-        self.assertEqual(repr(Perm.X), '<Perm.X: 1>')
-        self.assertEqual(repr(Perm.R | Perm.W), '<Perm.R|W: 6>')
-        self.assertEqual(repr(Perm.R | Perm.W | Perm.X), '<Perm.R|W|X: 7>')
-        self.assertEqual(repr(Perm.R | 8), '<Perm.8|R: 12>')
-        self.assertEqual(repr(Perm(0)), '<Perm.0: 0>')
-        self.assertEqual(repr(Perm(8)), '<Perm.8: 8>')
-        self.assertEqual(repr(~Perm.R), '<Perm.W|X: -5>')
-        self.assertEqual(repr(~Perm.W), '<Perm.R|X: -3>')
-        self.assertEqual(repr(~Perm.X), '<Perm.R|W: -2>')
-        self.assertEqual(repr(~(Perm.R | Perm.W)), '<Perm.X: -7>')
-        self.assertEqual(repr(~(Perm.R | Perm.W | Perm.X)), '<Perm.-8: -8>')
-        self.assertEqual(repr(~(Perm.R | 8)), '<Perm.W|X: -13>')
-        self.assertEqual(repr(Perm(~0)), '<Perm.R|W|X: -1>')
-        self.assertEqual(repr(Perm(~8)), '<Perm.R|W|X: -9>')
-
-        Open = self.Open
-        self.assertEqual(repr(Open.RO), '<Open.RO: 0>')
-        self.assertEqual(repr(Open.WO), '<Open.WO: 1>')
-        self.assertEqual(repr(Open.AC), '<Open.AC: 3>')
-        self.assertEqual(repr(Open.RO | Open.CE), '<Open.CE: 524288>')
-        self.assertEqual(repr(Open.WO | Open.CE), '<Open.CE|WO: 524289>')
-        self.assertEqual(repr(Open(4)), '<Open.4: 4>')
-        self.assertEqual(repr(~Open.RO), '<Open.CE|AC|RW|WO: -1>')
-        self.assertEqual(repr(~Open.WO), '<Open.CE|RW: -2>')
-        self.assertEqual(repr(~Open.AC), '<Open.CE: -4>')
-        self.assertEqual(repr(~(Open.RO | Open.CE)), '<Open.AC|RW|WO: -524289>')
-        self.assertEqual(repr(~(Open.WO | Open.CE)), '<Open.RW: -524290>')
-        self.assertEqual(repr(Open(~4)), '<Open.CE|AC|RW|WO: -5>')
-
-    def test_or(self):
-        Perm = self.Perm
-        for i in Perm:
-            for j in Perm:
-                self.assertEqual(i | j, i.value | j.value)
-                self.assertEqual((i | j).value, i.value | j.value)
-                self.assertIs(type(i | j), Perm)
-            for j in range(8):
-                self.assertEqual(i | j, i.value | j)
-                self.assertEqual((i | j).value, i.value | j)
-                self.assertIs(type(i | j), Perm)
-                self.assertEqual(j | i, j | i.value)
-                self.assertEqual((j | i).value, j | i.value)
-                self.assertIs(type(j | i), Perm)
-        for i in Perm:
-            self.assertIs(i | i, i)
-            self.assertIs(i | 0, i)
-            self.assertIs(0 | i, i)
-        Open = self.Open
-        self.assertIs(Open.RO | Open.CE, Open.CE)
-
-    def test_and(self):
-        Perm = self.Perm
-        RW = Perm.R | Perm.W
-        RX = Perm.R | Perm.X
-        WX = Perm.W | Perm.X
-        RWX = Perm.R | Perm.W | Perm.X
-        values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
-        for i in values:
-            for j in values:
-                self.assertEqual(i & j, i.value & j.value, 'i is %r, j is %r' % (i, j))
-                self.assertEqual((i & j).value, i.value & j.value, 'i is %r, j is %r' % (i, j))
-                self.assertIs(type(i & j), Perm, 'i is %r, j is %r' % (i, j))
-            for j in range(8):
-                self.assertEqual(i & j, i.value & j)
-                self.assertEqual((i & j).value, i.value & j)
-                self.assertIs(type(i & j), Perm)
-                self.assertEqual(j & i, j & i.value)
-                self.assertEqual((j & i).value, j & i.value)
-                self.assertIs(type(j & i), Perm)
-        for i in Perm:
-            self.assertIs(i & i, i)
-            self.assertIs(i & 7, i)
-            self.assertIs(7 & i, i)
-        Open = self.Open
-        self.assertIs(Open.RO & Open.CE, Open.RO)
-
-    def test_xor(self):
-        Perm = self.Perm
-        for i in Perm:
-            for j in Perm:
-                self.assertEqual(i ^ j, i.value ^ j.value)
-                self.assertEqual((i ^ j).value, i.value ^ j.value)
-                self.assertIs(type(i ^ j), Perm)
-            for j in range(8):
-                self.assertEqual(i ^ j, i.value ^ j)
-                self.assertEqual((i ^ j).value, i.value ^ j)
-                self.assertIs(type(i ^ j), Perm)
-                self.assertEqual(j ^ i, j ^ i.value)
-                self.assertEqual((j ^ i).value, j ^ i.value)
-                self.assertIs(type(j ^ i), Perm)
-        for i in Perm:
-            self.assertIs(i ^ 0, i)
-            self.assertIs(0 ^ i, i)
-        Open = self.Open
-        self.assertIs(Open.RO ^ Open.CE, Open.CE)
-        self.assertIs(Open.CE ^ Open.CE, Open.RO)
-
-    def test_invert(self):
-        Perm = self.Perm
-        RW = Perm.R | Perm.W
-        RX = Perm.R | Perm.X
-        WX = Perm.W | Perm.X
-        RWX = Perm.R | Perm.W | Perm.X
-        values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
-        for i in values:
-            self.assertEqual(~i, ~i.value)
-            self.assertEqual((~i).value, ~i.value)
-            self.assertIs(type(~i), Perm)
-            self.assertEqual(~~i, i)
-        for i in Perm:
-            self.assertIs(~~i, i)
-        Open = self.Open
-        self.assertIs(Open.WO & ~Open.WO, Open.RO)
-        self.assertIs((Open.WO|Open.CE) & ~Open.WO, Open.CE)
-
-    def test_programatic_function_string(self):
-        Perm = IntFlag('Perm', 'R W X')
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<i
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e, v)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_string_with_start(self):
-        Perm = IntFlag('Perm', 'R W X', start=8)
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 8<<i
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e, v)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_string_list(self):
-        Perm = IntFlag('Perm', ['R', 'W', 'X'])
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<i
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e, v)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_iterable(self):
-        Perm = IntFlag('Perm', (('R', 2), ('W', 8), ('X', 32)))
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<(2*i+1)
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e, v)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-    def test_programatic_function_from_dict(self):
-        Perm = IntFlag('Perm', OrderedDict((('R', 2), ('W', 8), ('X', 32))))
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 3, Perm)
-        self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
-        for i, n in enumerate('R W X'.split()):
-            v = 1<<(2*i+1)
-            e = Perm(v)
-            self.assertEqual(e.value, v)
-            self.assertEqual(type(e.value), int)
-            self.assertEqual(e, v)
-            self.assertEqual(e.name, n)
-            self.assertIn(e, Perm)
-            self.assertIs(type(e), Perm)
-
-
-    def test_programatic_function_from_empty_list(self):
-        Perm = enum.IntFlag('Perm', [])
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 0, Perm)
-        Thing = enum.Enum('Thing', [])
-        lst = list(Thing)
-        self.assertEqual(len(lst), len(Thing))
-        self.assertEqual(len(Thing), 0, Thing)
-
-
-    def test_programatic_function_from_empty_tuple(self):
-        Perm = enum.IntFlag('Perm', ())
-        lst = list(Perm)
-        self.assertEqual(len(lst), len(Perm))
-        self.assertEqual(len(Perm), 0, Perm)
-        Thing = enum.Enum('Thing', ())
-        self.assertEqual(len(lst), len(Thing))
-        self.assertEqual(len(Thing), 0, Thing)
-
-    def test_containment(self):
-        Perm = self.Perm
-        R, W, X = Perm
-        RW = R | W
-        RX = R | X
-        WX = W | X
-        RWX = R | W | X
-        self.assertTrue(R in RW)
-        self.assertTrue(R in RX)
-        self.assertTrue(R in RWX)
-        self.assertTrue(W in RW)
-        self.assertTrue(W in WX)
-        self.assertTrue(W in RWX)
-        self.assertTrue(X in RX)
-        self.assertTrue(X in WX)
-        self.assertTrue(X in RWX)
-        self.assertFalse(R in WX)
-        self.assertFalse(W in RX)
-        self.assertFalse(X in RW)
-
-    def test_bool(self):
-        Perm = self.Perm
-        for f in Perm:
-            self.assertTrue(f)
-        Open = self.Open
-        for f in Open:
-            self.assertEqual(bool(f.value), bool(f))
-
-    @unittest.skipUnless(threading, 'Threading required for this test.')
-    @support.reap_threads
-    def test_unique_composite(self):
-        # override __eq__ to be identity only
-        class TestFlag(IntFlag):
-            one = auto()
-            two = auto()
-            three = auto()
-            four = auto()
-            five = auto()
-            six = auto()
-            seven = auto()
-            eight = auto()
-            def __eq__(self, other):
-                return self is other
-            def __hash__(self):
-                return hash(self._value_)
-        # have multiple threads competing to complete the composite members
-        seen = set()
-        failed = False
-        def cycle_enum():
-            nonlocal failed
-            try:
-                for i in range(256):
-                    seen.add(TestFlag(i))
-            except Exception:
-                failed = True
-        threads = [
-                threading.Thread(target=cycle_enum)
-                for _ in range(8)
-                ]
-        with support.start_threads(threads):
-            pass
-        # check that only 248 members were created
-        self.assertFalse(
-                failed,
-                'at least one thread failed while creating composite members')
-        self.assertEqual(256, len(seen), 'too many composite members created')
-
-
-class TestUnique(unittest.TestCase):
-
-    def test_unique_clean(self):
-        @unique
-        class Clean(Enum):
-            one = 1
-            two = 'dos'
-            tres = 4.0
-        @unique
-        class Cleaner(IntEnum):
-            single = 1
-            double = 2
-            triple = 3
-
-    def test_unique_dirty(self):
-        with self.assertRaisesRegex(ValueError, 'tres.*one'):
-            @unique
-            class Dirty(Enum):
-                one = 1
-                two = 'dos'
-                tres = 1
-        with self.assertRaisesRegex(
-                ValueError,
-                'double.*single.*turkey.*triple',
-                ):
-            @unique
-            class Dirtier(IntEnum):
-                single = 1
-                double = 1
-                triple = 3
-                turkey = 3
-
-    def test_unique_with_name(self):
-        @unique
-        class Silly(Enum):
-            one = 1
-            two = 'dos'
-            name = 3
-        @unique
-        class Sillier(IntEnum):
-            single = 1
-            name = 2
-            triple = 3
-            value = 4
-
-
-expected_help_output_with_docs = """\
-Help on class Color in module %s:
-
-class Color(enum.Enum)
- |  An enumeration.
- |\x20\x20
- |  Method resolution order:
- |      Color
- |      enum.Enum
- |      builtins.object
- |\x20\x20
- |  Data and other attributes defined here:
- |\x20\x20
- |  blue = <Color.blue: 3>
- |\x20\x20
- |  green = <Color.green: 2>
- |\x20\x20
- |  red = <Color.red: 1>
- |\x20\x20
- |  ----------------------------------------------------------------------
- |  Data descriptors inherited from enum.Enum:
- |\x20\x20
- |  name
- |      The name of the Enum member.
- |\x20\x20
- |  value
- |      The value of the Enum member.
- |\x20\x20
- |  ----------------------------------------------------------------------
- |  Data descriptors inherited from enum.EnumMeta:
- |\x20\x20
- |  __members__
- |      Returns a mapping of member name->value.
- |\x20\x20\x20\x20\x20\x20
- |      This mapping lists all enum members, including aliases. Note that this
- |      is a read-only view of the internal mapping."""
-
-expected_help_output_without_docs = """\
-Help on class Color in module %s:
-
-class Color(enum.Enum)
- |  Method resolution order:
- |      Color
- |      enum.Enum
- |      builtins.object
- |\x20\x20
- |  Data and other attributes defined here:
- |\x20\x20
- |  blue = <Color.blue: 3>
- |\x20\x20
- |  green = <Color.green: 2>
- |\x20\x20
- |  red = <Color.red: 1>
- |\x20\x20
- |  ----------------------------------------------------------------------
- |  Data descriptors inherited from enum.Enum:
- |\x20\x20
- |  name
- |\x20\x20
- |  value
- |\x20\x20
- |  ----------------------------------------------------------------------
- |  Data descriptors inherited from enum.EnumMeta:
- |\x20\x20
- |  __members__"""
-
-class TestStdLib(unittest.TestCase):
-
-    maxDiff = None
-
-    class Color(Enum):
-        red = 1
-        green = 2
-        blue = 3
-
-    def test_pydoc(self):
-        # indirectly test __objclass__
-        if StrEnum.__doc__ is None:
-            expected_text = expected_help_output_without_docs % __name__
-        else:
-            expected_text = expected_help_output_with_docs % __name__
-        output = StringIO()
-        helper = pydoc.Helper(output=output)
-        helper(self.Color)
-        result = output.getvalue().strip()
-        self.assertEqual(result, expected_text)
-
-    def test_inspect_getmembers(self):
-        values = dict((
-                ('__class__', EnumMeta),
-                ('__doc__', 'An enumeration.'),
-                ('__members__', self.Color.__members__),
-                ('__module__', __name__),
-                ('blue', self.Color.blue),
-                ('green', self.Color.green),
-                ('name', Enum.__dict__['name']),
-                ('red', self.Color.red),
-                ('value', Enum.__dict__['value']),
-                ))
-        result = dict(inspect.getmembers(self.Color))
-        self.assertEqual(values.keys(), result.keys())
-        failed = False
-        for k in values.keys():
-            if result[k] != values[k]:
-                print()
-                print('\n%s\n     key: %s\n  result: %s\nexpected: %s\n%s\n' %
-                        ('=' * 75, k, result[k], values[k], '=' * 75), sep='')
-                failed = True
-        if failed:
-            self.fail("result does not equal expected, see print above")
-
-    def test_inspect_classify_class_attrs(self):
-        # indirectly test __objclass__
-        from inspect import Attribute
-        values = [
-                Attribute(name='__class__', kind='data',
-                    defining_class=object, object=EnumMeta),
-                Attribute(name='__doc__', kind='data',
-                    defining_class=self.Color, object='An enumeration.'),
-                Attribute(name='__members__', kind='property',
-                    defining_class=EnumMeta, object=EnumMeta.__members__),
-                Attribute(name='__module__', kind='data',
-                    defining_class=self.Color, object=__name__),
-                Attribute(name='blue', kind='data',
-                    defining_class=self.Color, object=self.Color.blue),
-                Attribute(name='green', kind='data',
-                    defining_class=self.Color, object=self.Color.green),
-                Attribute(name='red', kind='data',
-                    defining_class=self.Color, object=self.Color.red),
-                Attribute(name='name', kind='data',
-                    defining_class=Enum, object=Enum.__dict__['name']),
-                Attribute(name='value', kind='data',
-                    defining_class=Enum, object=Enum.__dict__['value']),
-                ]
-        values.sort(key=lambda item: item.name)
-        result = list(inspect.classify_class_attrs(self.Color))
-        result.sort(key=lambda item: item.name)
-        failed = False
-        for v, r in zip(values, result):
-            if r != v:
-                print('\n%s\n%s\n%s\n%s\n' % ('=' * 75, r, v, '=' * 75), sep='')
-                failed = True
-        if failed:
-            self.fail("result does not equal expected, see print above")
-
-
-class MiscTestCase(unittest.TestCase):
-    def test__all__(self):
-        support.check__all__(self, enum)
-
-
-# These are unordered here on purpose to ensure that declaration order
-# makes no difference.
-CONVERT_TEST_NAME_D = 5
-CONVERT_TEST_NAME_C = 5
-CONVERT_TEST_NAME_B = 5
-CONVERT_TEST_NAME_A = 5  # This one should sort first.
-CONVERT_TEST_NAME_E = 5
-CONVERT_TEST_NAME_F = 5
-
-class TestIntEnumConvert(unittest.TestCase):
-    def test_convert_value_lookup_priority(self):
-        test_type = enum.IntEnum._convert(
-                'UnittestConvert',
-                ('test.test_enum', '__main__')[__name__=='__main__'],
-                filter=lambda x: x.startswith('CONVERT_TEST_'))
-        # We don't want the reverse lookup value to vary when there are
-        # multiple possible names for a given value.  It should always
-        # report the first lexigraphical name in that case.
-        self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
-
-    def test_convert(self):
-        test_type = enum.IntEnum._convert(
-                'UnittestConvert',
-                ('test.test_enum', '__main__')[__name__=='__main__'],
-                filter=lambda x: x.startswith('CONVERT_TEST_'))
-        # Ensure that test_type has all of the desired names and values.
-        self.assertEqual(test_type.CONVERT_TEST_NAME_F,
-                         test_type.CONVERT_TEST_NAME_A)
-        self.assertEqual(test_type.CONVERT_TEST_NAME_B, 5)
-        self.assertEqual(test_type.CONVERT_TEST_NAME_C, 5)
-        self.assertEqual(test_type.CONVERT_TEST_NAME_D, 5)
-        self.assertEqual(test_type.CONVERT_TEST_NAME_E, 5)
-        # Ensure that test_type only picked up names matching the filter.
-        self.assertEqual([name for name in dir(test_type)
-                          if name[0:2] not in ('CO', '__')],
-                         [], msg='Names other than CONVERT_TEST_* found.')
-
-
-if __name__ == '__main__':
-    unittest.main()