class test_LilyPond(unittest.TestCase):
def setUp(self):
self.commonbar = Bar()
self.ebar = Bar('E', (4, 4))
self.fbar = Bar('F', (6, 8))
self.tbar = Bar('C', (4, 4))
self.mbar = Bar('C', (4, 4))
for y in [self.commonbar, self.ebar, self.fbar]:
map(lambda x: y + x, ['C', 'E', 'G', 'B'])
map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
'C',
'E',
'G',
'B',
'C',
'E',
])
map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E'])
map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C'
])
self.track1 = Track()
self.track1 + self.commonbar
self.track2 = Track()
self.track2 + self.commonbar
self.track2 + self.ebar
self.composition1 = Composition()
self.composition1.add_track(self.track1)
self.composition2 = Composition()
self.composition2.add_track(self.track1)
self.composition2.add_track(self.track2)
def test_from_Note(self):
self.assertEqual(LilyPond.from_Note(Note('C'), standalone=False), "c'")
self.assertEqual(LilyPond.from_Note(Note('C#'), standalone=False),
"cis'")
self.assertEqual(LilyPond.from_Note(Note('C##'), standalone=False),
"cisis'")
self.assertEqual(LilyPond.from_Note(Note('Cb'), standalone=False),
"ces'")
self.assertEqual(LilyPond.from_Note(Note('Cbb'), standalone=False),
"ceses'")
self.assertEqual(LilyPond.from_Note(Note('C', 0), standalone=False),
'c,,,')
self.assertEqual(LilyPond.from_Note(Note('C', 1), standalone=False),
'c,,')
self.assertEqual(LilyPond.from_Note(Note('C', 2), standalone=False),
'c,')
self.assertEqual(LilyPond.from_Note(Note('C', 3), standalone=False), 'c'
)
self.assertEqual(LilyPond.from_Note(Note('C', 4), standalone=False),
"c'")
self.assertEqual(LilyPond.from_Note(Note('C', 5), standalone=False),
"c''")
self.assertEqual(LilyPond.from_Note(Note('C', 6), standalone=False),
"c'''")
self.assertEqual(LilyPond.from_Note(Note('C', 7), standalone=False),
"c''''")
def test_from_NoteContainer(self):
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
standalone=False), "c'")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 4,
standalone=False), "c'4")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
standalone=False), "<c' e'>")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
4, standalone=False), "<c' e'>4")
# issue #37
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 16,
standalone=False), "c'16")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 16.0,
standalone=False), "c'16")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(16), standalone=False), "c'16.")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 0.25,
standalone=False), "c'\\longa")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'), 0.5,
standalone=False), "c'\\breve")
def test_from_Bar(self):
self.assertEqual(LilyPond.from_Bar(self.commonbar),
"{ \\time 4/4 \\key c \\major c'4 e'4 g'4 b'4 }")
self.assertEqual(LilyPond.from_Bar(self.ebar),
"{ \\time 4/4 \\key e \\major c'4 e'4 g'4 b'4 }")
self.assertEqual(LilyPond.from_Bar(self.fbar),
"{ \\time 6/8 \\key f \\major c'8 e'8 g'8 b'8 }")
def test_from_Track(self):
self.assertEqual(LilyPond.from_Track(self.track1),
"{ { c'4 e'4 g'4 b'4 } }")
self.assertEqual(LilyPond.from_Track(self.track2),
"{ { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }"
)
def test_from_Composition(self):
self.assertEqual(LilyPond.from_Composition(self.composition1),
'\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } }'
)
self.assertEqual(LilyPond.from_Composition(self.composition2),
'\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } } { { c\'4 e\'4 g\'4 b\'4 } { \\key e \\major c\'4 e\'4 g\'4 b\'4 } }'
)
def test_from_Suite(self):
LilyPond.from_Suite(None)
def test_dotted_notes(self):
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(8), standalone=False), "c'8.")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(4, 2), standalone=False), "c'4..")
def test_to_pdf(self):
self.assert_(LilyPond.to_pdf('{ %s }'
% LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(8)), 'pdftest first test'))
self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.tbar), 'pdftest2'))
self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.mbar), 'pdftest3'))
def test_to_png(self):
self.assert_(LilyPond.to_png('{ %s }'
% LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(8)), 'pn1'))
self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.tbar), 'pn2'))
self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.mbar), 'pn3'))
class test_LilyPond(unittest.TestCase):
def setUp(self):
self.commonbar = Bar()
self.ebar = Bar("E", (4, 4))
self.fbar = Bar("F", (6, 8))
self.tbar = Bar("C", (4, 4))
self.mbar = Bar("C", (4, 4))
self.a_minor_bar = Bar("a", (4, 4))
self.b_flat_minor_bar = Bar("bb", (4, 4))
self.f_sharp_minor_bar = Bar("f#", (4, 4))
for y in [self.commonbar, self.ebar, self.fbar]:
map(lambda x: y + x, ["C", "E", "G", "B"])
map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), ["C", "E", "G", "B", "C", "E"])
map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ["C", "E"])
map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ["G", "B", "C"])
self.track1 = Track()
self.track1 + self.commonbar
self.track2 = Track()
self.track2 + self.commonbar
self.track2 + self.ebar
self.composition1 = Composition()
self.composition1.add_track(self.track1)
self.composition2 = Composition()
self.composition2.add_track(self.track1)
self.composition2.add_track(self.track2)
def test_from_Note(self):
self.assertEqual(LilyPond.from_Note(Note("C"), standalone=False), "c'")
self.assertEqual(LilyPond.from_Note(Note("C#"), standalone=False), "cis'")
self.assertEqual(LilyPond.from_Note(Note("C##"), standalone=False), "cisis'")
self.assertEqual(LilyPond.from_Note(Note("Cb"), standalone=False), "ces'")
self.assertEqual(LilyPond.from_Note(Note("Cbb"), standalone=False), "ceses'")
self.assertEqual(LilyPond.from_Note(Note("C", 0), standalone=False), "c,,,")
self.assertEqual(LilyPond.from_Note(Note("C", 1), standalone=False), "c,,")
self.assertEqual(LilyPond.from_Note(Note("C", 2), standalone=False), "c,")
self.assertEqual(LilyPond.from_Note(Note("C", 3), standalone=False), "c")
self.assertEqual(LilyPond.from_Note(Note("C", 4), standalone=False), "c'")
self.assertEqual(LilyPond.from_Note(Note("C", 5), standalone=False), "c''")
self.assertEqual(LilyPond.from_Note(Note("C", 6), standalone=False), "c'''")
self.assertEqual(LilyPond.from_Note(Note("C", 7), standalone=False), "c''''")
def test_from_NoteContainer(self):
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), standalone=False), "c'")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 4, standalone=False), "c'4")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(["C", "E"]), standalone=False), "<c' e'>")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer(["C", "E"]), 4, standalone=False), "<c' e'>4")
# issue #37
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 16, standalone=False), "c'16")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 16.0, standalone=False), "c'16")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(16), standalone=False), "c'16.")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 0.25, standalone=False), "c'\\longa")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), 0.5, standalone=False), "c'\\breve")
def test_from_Bar(self):
self.assertEqual(LilyPond.from_Bar(self.commonbar), "{ \\time 4/4 \\key c \\major c'4 e'4 g'4 b'4 }")
self.assertEqual(LilyPond.from_Bar(self.ebar), "{ \\time 4/4 \\key e \\major c'4 e'4 g'4 b'4 }")
self.assertEqual(LilyPond.from_Bar(self.fbar), "{ \\time 6/8 \\key f \\major c'8 e'8 g'8 b'8 }")
self.assertEqual(LilyPond.from_Bar(self.a_minor_bar), "{ \\time 4/4 \\key a \\minor }")
self.assertEqual(LilyPond.from_Bar(self.b_flat_minor_bar), "{ \\time 4/4 \\key bes \\minor }")
self.assertEqual(LilyPond.from_Bar(self.f_sharp_minor_bar), "{ \\time 4/4 \\key fis \\minor }")
def test_from_Track(self):
self.assertEqual(LilyPond.from_Track(self.track1), "{ { c'4 e'4 g'4 b'4 } }")
self.assertEqual(
LilyPond.from_Track(self.track2), "{ { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }"
)
def test_from_Composition(self):
self.assertEqual(
LilyPond.from_Composition(self.composition1),
'\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } }',
)
self.assertEqual(
LilyPond.from_Composition(self.composition2),
"\\header { title = \"Untitled\" composer = \"\" opus = \"\" } { { c'4 e'4 g'4 b'4 } } { { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }",
)
def test_from_Suite(self):
LilyPond.from_Suite(None)
def test_dotted_notes(self):
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(8), standalone=False), "c'8.")
self.assertEqual(LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(4, 2), standalone=False), "c'4..")
def test_to_pdf(self):
self.assert_(
LilyPond.to_pdf(
"{ %s }" % LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(8)), "pdftest first test"
)
)
self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.tbar), "pdftest2"))
self.assert_(LilyPond.to_pdf(LilyPond.from_Bar(self.mbar), "pdftest3"))
def test_to_png(self):
self.assert_(LilyPond.to_png("{ %s }" % LilyPond.from_NoteContainer(NoteContainer("C"), value.dots(8)), "pn1"))
self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.tbar), "pn2"))
self.assert_(LilyPond.to_png(LilyPond.from_Bar(self.mbar), "pn3"))
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
c = Composition()
if header[2]['fps']:
print("Don't know how to parse this yet")
return c
ticks_per_beat = header[2]['ticks_per_beat']
for track in track_data:
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = 'C'
for e in track:
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if duration != 0.0:
duration = 1.0 / duration
if len(b.bar) > 0:
current_length = b.bar[-1][1]
b.bar[-1][1] = duration
if current_length - duration != 0:
b.current_beat -= 1.0 / current_length
b.current_beat += 1.0 / duration
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event['event'] == 8:
if deltatime == 0:
pass
elif event['event'] == 9:
# note on
n = Note(notes.int_to_note(event['param1'] % 12),
event['param1'] / 12 - 1)
n.channel = event['channel']
n.velocity = event['param2']
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event['param1']
t.instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
t.name = event['data']
elif event['meta_event'] == 6:
# Marker
pass
elif event['meta_event'] == 7:
# Cue Point
pass
elif event['meta_event'] == 47:
# End of Track
pass
elif event['meta_event'] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event['data'])
bpm = 60000000 / mpqn
elif event['meta_event'] == 88:
# Time Signature
d = event['data']
thirtyseconds = self.bytes_to_int(d[3])
metronome = self.bytes_to_int(d[2]) / 24.0
denom = 2**self.bytes_to_int(d[1])
numer = self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event['meta_event'] == 89:
# Key Signature
d = event['data']
sharps = self.bytes_to_int(d[0])
minor = self.bytes_to_int(d[0])
if minor:
key = 'A'
else:
key = 'C'
for i in xrange(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Note(key)
else:
print("Unsupported META event", event['meta_event'])
else:
print("Unsupported MIDI event", event)
t + b
c.tracks.append(t)
return (c, bpm)
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
c = Composition()
if header[2]['fps']:
print "Don't know how to parse this yet"
return c
ticks_per_beat = header[2]['ticks_per_beat']
for track in track_data:
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = 'C'
for e in track:
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if duration != 0.0:
duration = 1.0 / duration
if deltatime != 0:
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event['event'] == 8:
if deltatime == 0:
pass
elif event['event'] == 9:
# note on
n = Note(notes.int_to_note(event['param1'] % 12),
event['param1'] / 12 - 1)
n.channel = event['channel']
n.velocity = event['param2']
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event['param1']
t.instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
t.name = event['data']
elif event['meta_event'] == 6:
# Marker
pass
elif event['meta_event'] == 7:
# Cue Point
pass
elif event['meta_event'] == 47:
# End of Track
pass
elif event['meta_event'] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event['data'])
bpm = 60000000 / mpqn
elif event['meta_event'] == 88:
# Time Signature
d = event['data']
thirtyseconds = self.bytes_to_int(d[3])
metronome = self.bytes_to_int(d[2]) / 24.0
denom = 2 ** self.bytes_to_int(d[1])
numer = self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event['meta_event'] == 89:
# Key Signature
d = event['data']
sharps = self.bytes_to_int(d[0])
minor = self.bytes_to_int(d[0])
if minor:
key = 'A'
else:
key = 'C'
for i in xrange(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Note(key)
else:
print 'Unsupported META event', event['meta_event']
else:
print 'Unsupported MIDI event', event
t + b
c.tracks.append(t)
return (c, bpm)
class test_LilyPond(unittest.TestCase):
def setUp(self):
self.commonbar = Bar()
self.ebar = Bar('E', (4, 4))
self.fbar = Bar('F', (6, 8))
self.tbar = Bar('C', (4, 4))
self.mbar = Bar('C', (4, 4))
self.a_minor_bar = Bar('a', (4, 4))
self.b_flat_minor_bar = Bar('bb', (4, 4))
self.f_sharp_minor_bar = Bar('f#', (4, 4))
for y in [self.commonbar, self.ebar, self.fbar]:
list(map(lambda x: y + x, ['C', 'E', 'G', 'B']))
list(
map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
'C',
'E',
'G',
'B',
'C',
'E',
]))
list(
map(lambda x: self.mbar.place_notes(NoteContainer(x), 4),
['C', 'E']))
list(
map(lambda x: self.mbar.place_notes(NoteContainer(x), 6),
['G', 'B', 'C']))
self.track1 = Track()
self.track1 + self.commonbar
self.track2 = Track()
self.track2 + self.commonbar
self.track2 + self.ebar
self.composition1 = Composition()
self.composition1.add_track(self.track1)
self.composition2 = Composition()
self.composition2.add_track(self.track1)
self.composition2.add_track(self.track2)
def test_from_Note(self):
self.assertEqual(LilyPond.from_Note(Note('C'), standalone=False), "c'")
self.assertEqual(LilyPond.from_Note(Note('C#'), standalone=False),
"cis'")
self.assertEqual(LilyPond.from_Note(Note('C##'), standalone=False),
"cisis'")
self.assertEqual(LilyPond.from_Note(Note('Cb'), standalone=False),
"ces'")
self.assertEqual(LilyPond.from_Note(Note('Cbb'), standalone=False),
"ceses'")
self.assertEqual(LilyPond.from_Note(Note('C', 0), standalone=False),
'c,,,')
self.assertEqual(LilyPond.from_Note(Note('C', 1), standalone=False),
'c,,')
self.assertEqual(LilyPond.from_Note(Note('C', 2), standalone=False),
'c,')
self.assertEqual(LilyPond.from_Note(Note('C', 3), standalone=False),
'c')
self.assertEqual(LilyPond.from_Note(Note('C', 4), standalone=False),
"c'")
self.assertEqual(LilyPond.from_Note(Note('C', 5), standalone=False),
"c''")
self.assertEqual(LilyPond.from_Note(Note('C', 6), standalone=False),
"c'''")
self.assertEqual(LilyPond.from_Note(Note('C', 7), standalone=False),
"c''''")
def test_from_NoteContainer(self):
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'), standalone=False),
"c'")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
4,
standalone=False), "c'4")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
standalone=False), "<c' e'>")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer(['C', 'E']),
4,
standalone=False), "<c' e'>4")
# issue #37
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
16,
standalone=False), "c'16")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
16.0,
standalone=False), "c'16")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(16),
standalone=False), "c'16.")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
0.25,
standalone=False), "c'\\longa")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
0.5,
standalone=False), "c'\\breve")
def test_from_Bar(self):
self.assertEqual(LilyPond.from_Bar(self.commonbar),
"{ \\time 4/4 \\key c \\major c'4 e'4 g'4 b'4 }")
self.assertEqual(LilyPond.from_Bar(self.ebar),
"{ \\time 4/4 \\key e \\major c'4 e'4 g'4 b'4 }")
self.assertEqual(LilyPond.from_Bar(self.fbar),
"{ \\time 6/8 \\key f \\major c'8 e'8 g'8 b'8 }")
self.assertEqual(LilyPond.from_Bar(self.a_minor_bar),
"{ \\time 4/4 \\key a \\minor }")
self.assertEqual(LilyPond.from_Bar(self.b_flat_minor_bar),
"{ \\time 4/4 \\key bes \\minor }")
self.assertEqual(LilyPond.from_Bar(self.f_sharp_minor_bar),
"{ \\time 4/4 \\key fis \\minor }")
def test_from_Track(self):
self.assertEqual(LilyPond.from_Track(self.track1),
"{ { c'4 e'4 g'4 b'4 } }")
self.assertEqual(
LilyPond.from_Track(self.track2),
"{ { c'4 e'4 g'4 b'4 } { \\key e \\major c'4 e'4 g'4 b'4 } }")
def test_from_Composition(self):
self.assertEqual(
LilyPond.from_Composition(self.composition1),
'\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } }'
)
self.assertEqual(
LilyPond.from_Composition(self.composition2),
'\\header { title = "Untitled" composer = "" opus = "" } { { c\'4 e\'4 g\'4 b\'4 } } { { c\'4 e\'4 g\'4 b\'4 } { \\key e \\major c\'4 e\'4 g\'4 b\'4 } }'
)
def test_from_Suite(self):
LilyPond.from_Suite(None)
def test_dotted_notes(self):
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(8),
standalone=False), "c'8.")
self.assertEqual(
LilyPond.from_NoteContainer(NoteContainer('C'),
value.dots(4, 2),
standalone=False), "c'4..")
def test_to_pdf(self):
self.assertTrue(
LilyPond.to_pdf(
'{ %s }' %
LilyPond.from_NoteContainer(NoteContainer('C'), value.dots(8)),
'pdftest first test'))
self.assertTrue(
LilyPond.to_pdf(LilyPond.from_Bar(self.tbar), 'pdftest2'))
self.assertTrue(
LilyPond.to_pdf(LilyPond.from_Bar(self.mbar), 'pdftest3'))
def test_to_png(self):
self.assertTrue(
LilyPond.to_png(
'{ %s }' %
LilyPond.from_NoteContainer(NoteContainer('C'), value.dots(8)),
'pn1'))
self.assertTrue(LilyPond.to_png(LilyPond.from_Bar(self.tbar), 'pn2'))
self.assertTrue(LilyPond.to_png(LilyPond.from_Bar(self.mbar), 'pn3'))
