def test_method_name(self):
self.assertEqual(Method('&-12,1', 8).name, 'Untitled')
self.assertEqual(Method('&-12,1', 8, 'Bastow').name, 'Bastow')
m = Method('&-12,1', 8)
m.name = 'Bastow'
self.assertEqual(m.name, 'Bastow')
def test_method_name(self):
self.assertEqual(Method('&-12,1', 8).name, 'Untitled')
self.assertEqual(Method('&-12,1', 8, 'Bastow').name, 'Bastow')
m = Method('&-12,1', 8)
m.name = 'Bastow'
self.assertEqual(m.name, 'Bastow')
def test_method_issym(self):
self.assertTrue(Method().is_symmetric())
self.assertTrue(Method('&-1-1-1,2', 6).is_symmetric())
self.assertTrue(Method('&-1-1-1,1', 6).is_symmetric())
self.assertFalse(Method('3,&1-1-1-', 6).is_symmetric())
self.assertFalse(Method('3.1.5.1.5.1.5.1.5.123', 5).is_symmetric())
self.assertTrue(Method('&-4-36-5-1,8', 8).is_symmetric())
self.assertFalse(Method('+5.3.1.3.1.3', 5).is_symmetric())
def test_method_fullname_grandsire(self):
self.assertEqual(
Method('3,&1-1-1-', 6, 'Grandsire').full_name(), 'Grandsire Minor')
self.assertEqual(
Method('6,&1-1-1.4', 6, 'Reverse Grandsire').full_name(),
'Reverse Grandsire Minor')
self.assertEqual(
Method('3,&1-1-1.4', 6, 'Double Grandsire').full_name(),
'Double Grandsire Minor')
self.assertEqual(
Method('+3,&1.9.1.5.1', 9, 'Little Grandsire').full_name(),
'Little Grandsire Caters')
self.assertEqual(
Method('+3.1.7.1.7.1.7.1.7.1.7.1.5.1', 7, 'Union').full_name(),
'Union Triples')
def test_method_symmetry_point_assertion(self):
# Executing the following causes assertion failures in the library.
# Work around by raising ValueError instead.
self.assertRaises(ValueError, lambda: Method(3, 6).is_palindromic())
self.assertRaises(ValueError, lambda: Method(3, 6).is_palindromic(0))
self.assertRaises(ValueError, lambda: Method(3, 6).symmetry_point())
self.assertRaises(ValueError, lambda: Method(3, 6).symmetry_point(0))
self.assertRaises(ValueError,
lambda: Method(3, 6).format(symmetry=True))
self.assertRaises(ValueError,
lambda: Method(3, 6).format(full_symmetry=True))
# is_symmetric() shouldn't exhibit this problem
self.assertFalse(Method(3, 6).is_symmetric())
self.assertFalse(Method(3, 6).is_symmetric(0))
# Make sure __repr__ handles method with odd numbers of changes
self.assertEqual(repr(Method(2, 4)),
"Method('1234.1234', 4, 'Untitled')")
self.assertEqual(repr(Method(3, 4)),
"Method('+1234.1234.1234', 4, 'Untitled')")
def _process_data(self, file):
methods = super()._process_data(file)
for base_name, place_notation in methods.items():
try:
methods[base_name] = Method(
place_notation,
self.config_store.bells,
base_name,
)
except ValueError:
print('Could not parse method {0}'.format(base_name))
raise
return methods
def test_method_index_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(IndexError, lambda: m[-1])
m[0]
m[m.size - 1]
self.assertRaises(IndexError, lambda: m[m.size])
def assign_change(index):
m[index] = Change(6)
self.assertRaises(IndexError, lambda: assign_change(-1))
assign_change(0)
assign_change(m.size - 1)
self.assertRaises(IndexError, lambda: assign_change(m.size))
def test_method_constructor_exceptions(self):
self.assertRaises(TypeError, lambda: Method(input=self))
self.assertRaises(ValueError, lambda: Method(bells=-1))
Method(bells=0)
Method(bells=MAX_BELL_NUMBER)
self.assertRaises(ValueError,
lambda: Method(bells=MAX_BELL_NUMBER + 1))
self.assertRaises(TypeError, lambda: Method(name=self))
def test_method_fullname(self):
self.assertEqual(
Method('&-12,1', 8, 'Bastow').full_name(),
'Bastow Little Bob Major')
self.assertEqual(
Method('&34.1.5.1.5,2', 5,
'Reverse Canterbury Pleasure').full_name(),
'Reverse Canterbury Pleasure Place Doubles')
self.assertEqual(
Method('3.1', 3, 'Original').full_name(), 'Original Singles')
self.assertEqual(
Method('&-5-4.5-5.36.4-4.5-4-1,8', 8, 'Bristol').full_name(),
'Bristol Surprise Major')
self.assertEqual(
Method('-', 8, 'Cross').full_name(), 'Cross Differential Major')
self.assertEqual(
Method('-4-6-6-4-6-6-2', 6, "Tetley's Smoothflow").full_name(),
"Tetley's Smoothflow Differential Hybrid Minor")
def test_method_length(self):
self.assertEqual(Method('&-12,16', 6).length, 4)
self.assertEqual(Method('&-12,16', 6).size, 4)
self.assertEqual(Method().size, 0)
def test_method_lh(self):
self.assertEqual(Method().lead_head(), '')
self.assertEqual(Method('&-1-1-1-1,2', 8).lead_head(), '13527486')
self.assertEqual(Method('&-1-1-1-1,1', 8).lead_head(), '12345678')
self.assertEqual(Method('&-3-4-2-3-4-5,2', 6).lead_head(), '156342')
self.assertEqual(Method('+5.3.1.3.1.3', 5).lead_head(), '24153')
def test_method_symmetry_point_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(IndexError, lambda: m.symmetry_point(-1))
m.symmetry_point(0)
m.symmetry_point(5)
self.assertRaises(IndexError, lambda: m.symmetry_point(6))
def test_method_equals(self):
self.assertTrue(Method() == Method(0, 6, 'name'))
self.assertTrue(Method() == Method('', 9))
self.assertTrue(Method('-', 6) != Method('-', 4))
self.assertTrue(Method('&-12,1', 8) == Method('+ -12-18', 8))
def test_method_takes_bell_types(self):
m = Method('&-1-1-1,2', 6)
m.is_symmetric(Bell(0))
m.is_symmetric('1')
m.is_symmetric(0)
m.is_palindromic(Bell(0))
m.is_palindromic('1')
m.is_palindromic(0)
m.is_plain(Bell(0))
m.is_plain('1')
m.is_plain(0)
m.has_dodges(Bell(0))
m.has_dodges('1')
m.has_dodges(0)
m.has_places(Bell(0))
m.has_places('1')
m.has_places(0)
m.symmetry_point(Bell(0))
m.symmetry_point('1')
m.symmetry_point(0)
def test_method_has_places_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(ValueError, lambda: m.has_places(-1))
m.has_places(0)
m.has_places(5)
self.assertRaises(IndexError, lambda: m.has_places(6))
def test_method_is_palindromic_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(ValueError, lambda: m.is_palindromic(-1))
m.is_palindromic(0)
m.is_palindromic(5)
self.assertRaises(IndexError, lambda: m.is_palindromic(6))
def test_method_stagename(self):
self.assertEqual(Method.stage_name(0), '0') # ???
self.assertEqual(Method.stage_name(1), '1')
self.assertEqual(Method.stage_name(2), '2')
self.assertEqual(Method.stage_name(3), 'Singles')
self.assertEqual(Method.stage_name(4), 'Minimus')
self.assertEqual(Method.stage_name(5), 'Doubles')
self.assertEqual(Method.stage_name(6), 'Minor')
self.assertEqual(Method.stage_name(7), 'Triples')
self.assertEqual(Method.stage_name(8), 'Major')
self.assertEqual(Method.stage_name(9), 'Caters')
self.assertEqual(Method.stage_name(10), 'Royal')
self.assertEqual(Method.stage_name(11), 'Cinques')
self.assertEqual(Method.stage_name(12), 'Maximus')
self.assertEqual(Method.stage_name(13), 'Sextuples')
self.assertEqual(Method.stage_name(14), 'Fourteen')
self.assertEqual(Method.stage_name(15), 'Septuples')
self.assertEqual(Method.stage_name(16), 'Sixteen')
self.assertEqual(Method.stage_name(17), 'Octuples')
self.assertEqual(Method.stage_name(18), 'Eighteen')
self.assertEqual(Method.stage_name(19), 'Nonuples')
self.assertEqual(Method.stage_name(20), 'Twenty')
self.assertEqual(Method.stage_name(21), 'Decuples')
self.assertEqual(Method.stage_name(22), 'Twenty-two')
self.assertEqual(Method.stage_name(54), '54')
def test_method_is_plain_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(ValueError, lambda: m.is_plain(-1))
m.is_plain(0)
m.is_plain(5)
self.assertRaises(IndexError, lambda: m.is_plain(6))
def execute(self):
if self.composition.configs.has_config('calls'):
longest_call = max(map(
lambda s: len(s),
self.composition.configs.calls.keys()
))
format_string = ' {0.method_name}\n{0.call_symbol:' + \
str(longest_call) + '} {0.lead_head}'
else:
format_string = ' {0.method_name}\n{0.lead_head}'
file = os.path.join(self.get_output_directory(), 'composition.txt')
with open(file, 'w') as file:
def output(*args):
"""Prints a line to the output file without any newline."""
print(*args, end='', file=file)
# Title
output('{length} {stage}\n'.format(
length=self.composition.length,
stage=Method.stage_name(self.composition.configs.bells),
))
# Number of methods
methods = {}
for name, length in self.composition.method_balance.items():
# Assemble dict mapping lengths to lists of methods
# e.g. {176: ['Slinky'], 880: ['Maypole']}
if length not in methods:
methods[length] = []
methods[length].append(name)
for length in methods.keys():
# Replace each list of methods with string for output
# e.g. {176: '176 Slinky', 880: '880 Maypole'}
methods[length] = ', '.join(sorted(methods[length]))
methods[length] = '{0} {1}'.format(length, methods[length])
methods = [
# Sort entries in reverse order of length
# e.g. {880: '880 Maypole', 176: '176 Slinky'}
methods[length] for length
in reversed(sorted(methods.keys()))
]
output('({number}m: {methods})\n'.format(
number=len(self.composition.method_balance),
methods='; '.join(methods),
))
output('\n')
# Rows of the composition
if self.composition.configs.has_config('calls'):
output(' ' * (longest_call + 1))
output(Row(self.composition.configs.bells))
for lead in self.composition.leads:
output(format_string.format(lead))
output('\n')
output('\n')
# Composition statistics
output('{0.parts} part. {0.com} com.\n'.format(self.composition))
def test_method_symmetry_point_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(ValueError, lambda: m.symmetry_point(-1))
m.symmetry_point(0)
m.symmetry_point(5)
self.assertRaises(IndexError, lambda: m.symmetry_point(6))
def test_method_is_palindromic_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(IndexError, lambda: m.is_palindromic(-1))
m.is_palindromic(0)
m.is_palindromic(5)
self.assertRaises(IndexError, lambda: m.is_palindromic(6))
def test_method_is_plain_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(IndexError, lambda: m.is_plain(-1))
m.is_plain(0)
m.is_plain(5)
self.assertRaises(IndexError, lambda: m.is_plain(6))
def test_method_has_places_limits(self):
m = Method('&-1-1-1,2', 6)
self.assertRaises(IndexError, lambda: m.has_places(-1))
m.has_places(0)
m.has_places(5)
self.assertRaises(IndexError, lambda: m.has_places(6))
def test_method_stagename(self):
self.assertEqual(Method.stage_name(0), '0') # ???
self.assertEqual(Method.stage_name(1), '1')
self.assertEqual(Method.stage_name(2), '2')
self.assertEqual(Method.stage_name(3), 'Singles')
self.assertEqual(Method.stage_name(4), 'Minimus')
self.assertEqual(Method.stage_name(5), 'Doubles')
self.assertEqual(Method.stage_name(6), 'Minor')
self.assertEqual(Method.stage_name(7), 'Triples')
self.assertEqual(Method.stage_name(8), 'Major')
self.assertEqual(Method.stage_name(9), 'Caters')
self.assertEqual(Method.stage_name(10), 'Royal')
self.assertEqual(Method.stage_name(11), 'Cinques')
self.assertEqual(Method.stage_name(12), 'Maximus')
self.assertEqual(Method.stage_name(13), 'Sextuples')
self.assertEqual(Method.stage_name(14), 'Fourteen')
self.assertEqual(Method.stage_name(15), 'Septuples')
self.assertEqual(Method.stage_name(16), 'Sixteen')
self.assertEqual(Method.stage_name(17), 'Octuples')
self.assertEqual(Method.stage_name(18), 'Eighteen')
self.assertEqual(Method.stage_name(19), 'Nonuples')
self.assertEqual(Method.stage_name(20), 'Twenty')
self.assertEqual(Method.stage_name(21), 'Decuples')
self.assertEqual(Method.stage_name(22), 'Twenty-two')
self.assertEqual(Method.stage_name(54), '54')
def test_method_bells(self):
self.assertEqual(Method('', 6).bells, 6)
self.assertEqual(Method('&-1-1-1,2', 6).bells, 6)
