def test_value_attributes(self):
""" Enumeration should have attributes for each value. """
for enumtype, params in self.valid_values.items():
for i, key in enumerate(params['keys']):
instance = getattr(enumtype, key)
test_value = enum.EnumValue(enumtype, i, key)
self.failUnlessEqual(test_value, instance)
def test_value_items(self):
""" Enumeration should have items for each value. """
for enumtype, params in self.valid_values.items():
for i, key in enumerate(params['keys']):
value = enumtype[i]
test_value = enum.EnumValue(enumtype, i, key)
self.failUnlessEqual(test_value, value)
def test_compare_equal(self):
""" An EnumValue should compare equal to its value. """
for enumtype, params in self.valid_values.items():
for i, key in enumerate(params['keys']):
instance = params['values'][key]
self.failUnlessEqual(instance,
enum.EnumValue(enumtype, i, key))
def test_sequence_other_values(self):
""" An EnumValue should compare sequentially to other values. """
test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
test_list = list(self.other_values)
test_list.append(test_value)
test_list.sort()
self.failUnless(test_value in test_list)
def test_compare_equality_different_enum(self):
""" An EnumValue should compare inequal to values of other enums. """
for enumtype, params in self.valid_values.items():
for i, key in enumerate(params['keys']):
instance = params['values'][key]
test_value = enum.EnumValue(self.SimpleEnum, i, key)
self.failIfEqual(test_value, instance)
def test_compare_unequal(self):
""" An EnumValue should compare different to other values. """
for enumtype, params in self.valid_values.items():
for i, key in enumerate(params['keys']):
instance = params['values'][key]
self.failIfEqual(instance,
enum.EnumValue(enumtype, None, None))
def test_compare_non_enum(self):
""" An EnumValue should not implement comparison to other types. """
test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
for other_value in self.other_values:
for compare_func in compare_functions:
compare_method = getattr(test_value, compare_func.__name__)
compare_result = compare_method(other_value)
self.failUnlessEqual(NotImplemented, compare_result)
def test_cmp_different_enum(self):
""" An EnumValue should not implement comparison to other enums """
for enumtype, params in self.iterate_params():
for i, key in enumerate(params['keys']):
instance = params['values'][key]
test_value = enum.EnumValue(self.SimpleEnum, i, key)
compare_result = instance.__cmp__(test_value)
self.failUnlessEqual(NotImplemented, compare_result)
def test_cmp_sequence(self):
""" EnumValue instances should compare as their sequence order """
for enumtype, params in self.iterate_params():
for i, left_key in enumerate(params['keys']):
for j, right_key in enumerate(params['keys']):
self.failUnlessEqual(
cmp(i, j),
cmp(params['values'][left_key],
enum.EnumValue(enumtype, j, right_key)))
def test_compare_different_enum(self):
""" An EnumValue should not implement comparison to other enums. """
for enumtype, params in self.valid_values.items():
for i, key in enumerate(params['keys']):
for compare_func in compare_functions:
instance = params['values'][key]
test_value = enum.EnumValue(self.SimpleEnum, i, key)
compare_method = getattr(instance, compare_func.__name__)
compare_result = compare_method(test_value)
self.failUnlessEqual(NotImplemented, compare_result)
def test_compare_sequence(self):
""" EnumValue instances should compare as their sequence order. """
for enumtype, params in self.valid_values.items():
for i, left_key in enumerate(params['keys']):
for j, right_key in enumerate(params['keys']):
for compare_func in compare_functions:
self.failUnlessEqual(
compare_func(i, j),
compare_func(
params['values'][left_key],
enum.EnumValue(enumtype, j, right_key)))
def test_compare_equality_non_enum(self):
""" An EnumValue should compare inequal to any other value. """
test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
for other_value in self.other_values:
self.failIfEqual(test_value, other_value)
def setup_enum_value_fixtures(testcase):
""" Set up fixtures for test cases using ‘EnumValue’. """
testcase.bad_keys = [
None,
0,
1,
(),
Mock_Enum(),
enum.EnumValue(Mock_Enum(), 0, 'bogus'),
]
testcase.other_values = [
None,
0,
1,
(),
Mock_Enum(),
"bogus",
enum.EnumValue(Mock_Enum(), 0, 'bogus'),
]
testcase.planets = [
('mercury', "Mercury"),
('venus', "Venus"),
('earth', "Earth"),
('mars', "Mars"),
('jupiter', "Jupiter"),
('saturn', "Saturn"),
('uranus', "Uranus"),
('neptune', "Neptune"),
]
planet_keys = [key for (key, name) in testcase.planets]
colour_keys = [
'red',
'green',
'blue',
'yellow',
'orange',
'purple',
'white',
'black',
]
simple_keys = ['spam', 'eggs', 'beans']
testcase.SimpleEnum = testcase.enum_factory_class(*simple_keys)
Colour = testcase.enum_factory_class(*colour_keys)
Planet = testcase.enum_factory_class(*planet_keys)
testcase.valid_values = {
Colour: dict(keys=colour_keys, ),
Planet: dict(keys=planet_keys, ),
}
for enumtype, params in testcase.valid_values.items():
params['enumtype'] = enumtype
values = {}
for i, key in enumerate(params['keys']):
values[key] = enum.EnumValue(enumtype, i, key)
params['values'] = values
def test_cmp_non_enum(self):
""" An EnumValue should not implement comparison to other types """
test_value = enum.EnumValue(self.SimpleEnum, 0, 'test')
for other_value in self.other_values:
compare_result = test_value.__cmp__(other_value)
self.failUnlessEqual(NotImplemented, compare_result)
def setUp(self):
""" Set up the test fixtures """
self.bad_keys = [
None,
0,
1,
(),
Mock_Enum(),
enum.EnumValue(Mock_Enum(), 0, 'bogus'),
]
self.other_values = [
None,
0,
1,
(),
Mock_Enum(),
"bogus",
enum.EnumValue(Mock_Enum(), 0, 'bogus'),
]
self.planet_dict = dict(
mercury="Mercury",
venus="Venus",
earth="Earth",
mars="Mars",
jupiter="Jupiter",
saturn="Saturn",
neptune="Neptune",
uranus="Uranus",
pluto="Pluto",
)
planet_keys = self.planet_dict.keys()
colour_keys = [
'red',
'green',
'blue',
'yellow',
'orange',
'purple',
'white',
'black',
]
simple_keys = ['spam', 'eggs', 'beans']
self.SimpleEnum = self.enum_factory_class(*simple_keys)
Colour = self.enum_factory_class(*colour_keys)
Planet = self.enum_factory_class(*planet_keys)
self.valid_values = {
Colour: dict(keys=colour_keys),
Planet: dict(keys=self.planet_dict.keys(), ),
}
for enumtype, params in self.valid_values.items():
params['enumtype'] = enumtype
values = {}
for i, key in enumerate(params['keys']):
values[key] = enum.EnumValue(enumtype, i, key)
params['values'] = values
