def test_clefs(self):
parser = ParserGABC(root='clef')
for clef in ['c1', 'c2', 'c3', 'c4', 'f3', 'f4', 'cb3', 'cb4']:
parse = parser.parse(clef)
element = visitParseTree(parse, VisitorGABC())
self.assertIsInstance(element, clef21.TrebleClef)
self.assertEqual(element.editorial.gabc, clef)
def test_multipleNeumes(self):
parser = ParserGABC(root='syllable')
parse = parser.parse('A(fg/fg)')
syllable = visitParseTree(parse, VisitorGABC())
self.assertEqual(syllable.lyric, 'A')
self.assertEqual(len(syllable.flat.notes), 4)
self.assertEqual(len(syllable), 2)
def test_flatClefs(self):
"""Test whether flats are NOT reset by syllable boundaries"""
parser = ParserGABC(root='body')
parse = parser.parse('(cb2) (e)')
stream = visitParseTree(parse, VisitorGABC())
notes = stream.flat.notes
self.assertEqual(notes[0].name, 'B-')
def test_mergeWords3(self):
gabc = "(c4) A(f) (,) (c) B(g)"
parser = ParserGABC()
parse = parser.parse(gabc)
ch = visitParseTree(parse, VisitorGABC())
ch.joinTextAcrossPausas()
self.assertEqual(len(ch[0].elements), 3)
def test_macros(self):
"""Test whether a file with macro's is converted properly despite them"""
parser = ParserGABC(root='file')
parse = parser.parse(
'%%\ndef-m1:\grealign;\ndef-m2:\grealign;\n(c2) a(f)')
elements = visitParseTree(parse, VisitorGABC())
self.assertTrue(True)
def test_notePrefix(self):
parser = ParserGABC(root='note')
parse = parser.parse('-f')
note = visitParseTree(parse, VisitorGABC())
ed = note.editorial
self.assertEqual(ed.gabcPosition, 'f')
self.assertEqual(ed.gabcPrefix, '-')
self.assertTrue(ed.liquescence)
def test_noteSuffixes(self):
parser = ParserGABC(root='note')
parse = parser.parse('fs<.')
note = visitParseTree(parse, VisitorGABC())
ed = note.editorial
self.assertEqual(ed.gabcPosition, 'f')
self.assertTrue({'neumeShape': 's<'} in ed.gabcSuffixes)
self.assertTrue({'rhythmicSign': '.'} in ed.gabcSuffixes)
def test_multipleHeaders(self):
parser = ParserGABC()
fileStr = 'attr1:value1;\n%%\nattr2:value2;\n%%\n(c2) A(f)'
parse = parser.parse(fileStr)
ch = visitParseTree(parse, VisitorGABC())
metadata = {'attr1': 'value1', 'attr2': 'value2'}
self.assertEqual(metadata['attr1'], 'value1')
self.assertEqual(metadata['attr2'], 'value2')
def test_multipleSuffixes(self):
parser = ParserGABC(root='note')
parse = parser.parse('go1')
n = visitParseTree(parse, VisitorGABC())
suffixes = n.editorial.gabcSuffixes
self.assertTrue({'neumeShape': 'o'} in suffixes)
self.assertTrue({'neumeShape': '1'} in suffixes)
self.assertEqual(n.editorial.gabcPosition, 'g')
def test_polyphonicAlterations(self):
parser = ParserGABC(root='music')
parse = parser.parse('f{ix}g')
elements = visitParseTree(parse, VisitorGABC())
n1, alt, n2 = elements
self.assertIsInstance(n1, chant.Neume)
self.assertIsInstance(alt, chant.Flat)
self.assertIsInstance(n2, chant.Neume)
def test_textAfterAccidental(self):
parser = ParserGABC(root='body')
parse = parser.parse('(c2) bla(eye)')
ch = visitParseTree(parse, VisitorGABC())
word1, word2 = ch[0]
self.assertIsNone(word1.flatLyrics)
self.assertEqual(word2.flatLyrics, 'bla')
note = word2.flat.notes[0]
self.assertEqual(note.lyric, 'bla')
def test_word(self):
parser = ParserGABC(root='word')
parse = parser.parse('A(f)B(g)')
word = visitParseTree(parse, VisitorGABC())
obj = word.toObject()
self.assertEqual(len(obj['elements']), 2)
del obj['elements']
targetObj = {'type': 'word', 'musicAndTextAligned': None}
self.assertDictEqual(obj, targetObj)
def test_syllable(self):
parser = ParserGABC(root='syllable')
parse = parser.parse('A(f)')
syll = visitParseTree(parse, VisitorGABC())
obj = syll.toObject()
self.assertEqual(len(obj['elements']), 1)
del obj['elements']
targetObj = {'type': 'syllable', 'lyric': 'A'}
self.assertDictEqual(obj, targetObj)
def test_breath_mark(self):
"""Test whether breath marks reset the accidentals"""
parser = ParserGABC(root='body')
parse = parser.parse('(c2) (exe,fe)')
stream = visitParseTree(parse, VisitorGABC())
notes = stream.flat.notes
self.assertEqual(notes[0].name, 'B-')
self.assertEqual(notes[1].name, 'C')
self.assertEqual(notes[2].name, 'B')
def test_twoSyllables(self):
parser = ParserGABC(root='word')
parse = parser.parse('s1(f)s2(f)')
word = visitParseTree(parse, VisitorGABC())
syll1, syll2 = word.syllables
lyric1 = syll1.flat.notes[0].lyrics[0]
lyric2 = syll2.flat.notes[0].lyrics[0]
self.assertEqual(lyric1.syllabic, 'begin')
self.assertEqual(lyric2.syllabic, 'end')
def test_multipleSyllablesWithCommas2(self):
"""Test whether syllables separated by commas are correctly
merged; including the last one"""
parser = ParserGABC(root='word')
gabc = 'a(f)(,)(f)(,)(f)'
parse = parser.parse(gabc)
word = visitParseTree(parse, VisitorGABC())
word.joinSyllablesAcrossPausas()
self.assertEqual(len(word), 1)
def test_alterations(self):
parser = ParserGABC(root='alteration')
for alteration in 'xy':
parse = parser.parse(f'f{alteration}')
element = visitParseTree(parse, VisitorGABC())
ed = element.editorial
self.assertIsInstance(element, chant.Alteration)
self.assertEqual(ed.gabcPosition, 'f')
self.assertEqual(ed.gabcAlteration, alteration)
def test_wordBoundaries(self):
"""Test whether word boundaries reset accidentals"""
parser = ParserGABC(root='body')
parse = parser.parse('(c2) a(exfe) c(e)')
stream = visitParseTree(parse, VisitorGABC())
notes = stream.flat.notes
self.assertEqual(notes[0].name, 'C')
self.assertEqual(notes[1].name, 'B-')
self.assertEqual(notes[2].name, 'B')
def test_syllableWithAnnotation(self):
parser = ParserGABC(root='syllable')
parse = parser.parse('*(:)')
syll = visitParseTree(parse, VisitorGABC())
obj = syll.toObject()
self.assertEqual(len(obj['elements']), 1)
del obj['elements']
targetObj = {'annotation': '*', 'type': 'syllable'}
self.assertDictEqual(obj, targetObj)
def test_multipleNeumes(self):
parser = ParserGABC(root='music')
parse = parser.parse('eh/hi')
elements = visitParseTree(parse, VisitorGABC())
self.assertEqual(len(elements), 2)
self.assertIsInstance(elements[0], chant.Neume)
self.assertEqual(len(elements[0]), 2)
self.assertIsInstance(elements[1], chant.Neume)
self.assertEqual(len(elements[1]), 2)
def test_articulationBeforeComma(self):
parser = ParserGABC(root='body')
parse = parser.parse("(c2) A(a,d)")
ch = visitParseTree(parse, VisitorGABC())
ch.makeBreathMarks()
clef, n1, n2 = ch.flat
self.assertIsInstance(clef, chant.Clef)
self.assertIsInstance(n1, chant.Note)
self.assertIsInstance(n2, chant.Note)
self.assertEqual(len(n1.articulations), 1)
def test_fileWithoutHeader(self):
parser = ParserGABC(root='file')
fileStr = '(c2) a(f)b(g) c(h)\ni(j)'
parse = parser.parse(fileStr)
ch = visitParseTree(parse, VisitorGABC())
notes = ch.flat.notes
self.assertEqual(notes[0].name, 'C')
self.assertEqual(notes[1].name, 'D')
self.assertEqual(notes[2].name, 'E')
self.assertEqual(notes[3].name, 'G')
def test_multipleSyllablesWithCommas(self):
parser = ParserGABC(root='word')
gabc = 'a(f)(,)(f)(,)(f)b(f)'
parse = parser.parse(gabc)
word = visitParseTree(parse, VisitorGABC())
word.joinSyllablesAcrossPausas()
self.assertEqual(len(word), 2)
syll1, syll2 = word.elements
self.assertEqual(len(syll1.flat), 5)
self.assertIsInstance(syll1.flat[1], chant.Pausa)
self.assertEqual(len(syll2.flat), 1)
def test_pausa(self):
parser = ParserGABC(root='pausa')
pausaTypes = [(chant.PausaFinalis, ['::']),
(chant.PausaMajor, [':', ':?', ':\'']),
(chant.PausaMinor, [';', ';1', ';2']),
(chant.PausaMinima, [',', ',_', ',0', ',1', '`'])]
for pausaClass, examples in pausaTypes:
for gabc in examples:
parse = parser.parse(gabc)
element = visitParseTree(parse, VisitorGABC())
self.assertIsInstance(element, pausaClass)
self.assertEqual(element.editorial.gabc, gabc)
def test_threeOrMoreSyllables(self):
parser = ParserGABC(root='word')
parse = parser.parse('s1(f)s2(f)s3(g)s4(f)')
word = visitParseTree(parse, VisitorGABC())
s1, s2, s3, s4 = word.syllables
lyric1 = s1.flat.notes[0].lyrics[0]
lyric2 = s2.flat.notes[0].lyrics[0]
lyric3 = s3.flat.notes[0].lyrics[0]
lyric4 = s4.flat.notes[0].lyrics[0]
self.assertEqual(lyric1.syllabic, 'begin')
self.assertEqual(lyric2.syllabic, 'middle')
self.assertEqual(lyric3.syllabic, 'middle')
self.assertEqual(lyric4.syllabic, 'end')
def test_syllablesWithCommas2(self):
parser = ParserGABC(root='word')
gabc = 'a(fg/gh)(,)(hi/ij)'
parse = parser.parse(gabc)
word = visitParseTree(parse, VisitorGABC())
word.joinSyllablesAcrossPausas()
self.assertEqual(len(word), 1)
neume1, neume2, comma, neume3, neume4 = word[0].elements
self.assertIsInstance(neume1, chant.Neume)
self.assertIsInstance(neume2, chant.Neume)
self.assertIsInstance(comma, chant.Pausa)
self.assertIsInstance(neume3, chant.Neume)
self.assertIsInstance(neume4, chant.Neume)
def test_syllablesWithCommas3(self):
"""Test whether a new syllable starts if the next syllable
has sung text"""
parser = ParserGABC(root='word')
gabc = 'a(fg/gh)(,)b(hi/ij)'
parse = parser.parse(gabc)
word = visitParseTree(parse, VisitorGABC())
word.joinSyllablesAcrossPausas()
(neume1, neume2, comma), (neume3, neume4) = word
self.assertIsInstance(neume1, chant.Neume)
self.assertIsInstance(neume2, chant.Neume)
self.assertIsInstance(comma, chant.Pausa)
self.assertIsInstance(neume3, chant.Neume)
self.assertIsInstance(neume4, chant.Neume)
def test_text(self):
parser = ParserGABC(root='body')
parse = parser.parse('a(c2) word(e)1(f) word2(g)')
ch = visitParseTree(parse, VisitorGABC())
w1, w2, w3 = ch[0]
self.assertEqual(w1.flatLyrics, 'a')
self.assertEqual(w2.flatLyrics, 'word1')
self.assertEqual(w3.flatLyrics, 'word2')
syll1, syll2 = w2.elements
self.assertEqual(syll1.lyric, 'word')
self.assertEqual(syll2.lyric, '1')
self.assertEqual(syll1.flat.notes[0].lyric, 'word')
self.assertEqual(syll2.flat.notes[0].lyric, '1')
def test_singleNeume(self):
parser = ParserGABC(root='music')
parse = parser.parse('fgf')
elements = visitParseTree(parse, VisitorGABC())
self.assertEqual(len(elements), 1)
neume = elements[0]
self.assertEqual(len(neume), 3)
self.assertIsInstance(neume[0], note21.Note)
self.assertIsInstance(neume[1], note21.Note)
self.assertIsInstance(neume[2], note21.Note)
self.assertEqual(neume[0].editorial.gabcPosition, 'f')
self.assertEqual(neume[1].editorial.gabcPosition, 'g')
self.assertEqual(neume[2].editorial.gabcPosition, 'f')
def test_flats(self):
parser = ParserGABC(root='body')
parse = parser.parse('(c2) a(exee,e)')
stream = visitParseTree(parse, VisitorGABC())
flat = stream.flat[1]
self.assertIsInstance(flat, chant.Alteration)
self.assertEqual(flat.pitch.step, 'B')
notes = stream.flat.notes
self.assertEqual(notes[0].name, 'B-')
self.assertEqual(notes[0].pitch.accidental.name, 'flat')
self.assertEqual(notes[1].name, 'B-')
self.assertEqual(notes[1].pitch.accidental.name, 'flat')
self.assertEqual(notes[2].name, 'B')
self.assertIsNone(notes[2].pitch.accidental)