def test_oneNoteNeumes(self):
# Test single suffix
parser = ParserGABC(root='note')
parse = parser.parse('G~')
self.assertEqual(parse[0].rule_name, 'position')
self.assertEqual(parse[0].value, 'G')
self.assertEqual(parse[1].rule_name, 'suffix')
self.assertEqual(parse[1].value, '~')
self.assertEqual(parse[1][0].rule_name, 'neume_shape')
# Test two-character suffix
parse = parser.parse('Go~')
self.assertEqual(parse[0].rule_name, 'position')
self.assertEqual(parse[0].value, 'G')
self.assertEqual(parse[1].rule_name, 'suffix')
self.assertEqual(parse[1].value, 'o~')
self.assertEqual(parse[1][0].rule_name, 'neume_shape')
# Test all possible suffixes
# G~ G> g~ g< g> go g~ go< gw gv gV gs gs<
tests = [('G~', 'G', '~'), ('G>', 'G', '>'), ('g~', 'g', '~'),
('g<', 'g', '<'), ('g>', 'g', '>'), ('go', 'g', 'o'),
('g~', 'g', '~'), ('go<', 'g', 'o<'), ('gw', 'g', 'w'),
('gv', 'g', 'v'), ('gV', 'g', 'V'), ('gs', 'g', 's'),
('gs<', 'g', 's<')]
for string, position, suffix in tests:
parse = parser.parse(string)
self.assertEqual(parse[0].rule_name, 'position')
self.assertEqual(parse[0].value, position)
self.assertEqual(parse[1].value, suffix)
self.assertEqual(parse[1][0].rule_name, 'neume_shape')
def test_alteration(self):
parser = ParserGABC(root='alteration')
parse = parser.parse('gx')
self.assertEqual(parse.rule_name, 'alteration')
self.assertEqual(parse[0].rule_name, 'position')
self.assertEqual(parse[1].value, 'x')
parse = parser.parse('gy')
self.assertEqual(parse.rule_name, 'alteration')
self.assertEqual(parse[1].value, 'y')
parse = parser.parse('g#')
self.assertEqual(parse.rule_name, 'alteration')
self.assertEqual(parse[1].value, '#')
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_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_emptyCustos(self):
"""Custos without position, makes no sense, but included anyway"""
parser = ParserGABC(root='music')
parse = parser.parse('::+')
bar, custos = parse
self.assertEqual(custos.rule_name, 'custos')
self.assertEqual(custos.value, '+')
def test_header(self):
parser = ParserGABC(root='header')
header_str = "attr1: value1;\n\nattr2:value2;"
parse = parser.parse(header_str)
# Attribute 1
attr1 = parse[0]
self.assertEqual(attr1.rule_name, 'attribute')
# Key
self.assertEqual(attr1[0].rule_name, 'attribute_key')
self.assertEqual(attr1[0].value, 'attr1')
# Separator: colon
self.assertEqual(attr1[1].value, ': ')
# Value
self.assertEqual(attr1[2].rule_name, 'attribute_value')
self.assertEqual(attr1[2].value, 'value1')
# Attribute end
self.assertEqual(attr1[3].value, ';\n\n')
# Attribute 2
attr2 = parse[1]
self.assertEqual(attr2.rule_name, 'attribute')
# Key
self.assertEqual(attr2[0].rule_name, 'attribute_key')
self.assertEqual(attr2[0].value, 'attr2')
# Separator: colon
self.assertEqual(attr2[1].value, ':')
# Value
self.assertEqual(attr2[2].rule_name, 'attribute_value')
self.assertEqual(attr2[2].value, 'value2')
# Attribute end
self.assertEqual(attr2[3].value, ';')
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_emptyHeader(self):
parser = ParserGABC()
fileStr = '%%\na(f)b(g)'
parse = parser.parse(fileStr)
self.assertEqual(parse[0].rule_name, 'separator')
self.assertEqual(parse[1].rule_name, 'body')
self.assertEqual(parse[1].value, 'a | ( | f | ) | b | ( | g | ) | ')
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_emptyNotes(self):
parser = ParserGABC(root='note')
parse = parser.parse('gr')
self.assertEqual(parse[0].rule_name, 'position')
self.assertEqual(parse[0].value, 'g')
self.assertEqual(parse[1].rule_name, 'suffix')
self.assertEqual(parse[1].value, 'r')
self.assertEqual(parse[1][0].rule_name, 'empty_note_or_accent')
parse = parser.parse("gR")
self.assertEqual(parse[1].value, "R")
self.assertEqual(parse[1][0].rule_name, 'empty_note_or_accent')
parse = parser.parse("gr0")
self.assertEqual(parse[1].value, "r0")
self.assertEqual(parse[1][0].rule_name, 'empty_note_or_accent')
def test_positions(self):
parser = ParserGABC(root='note')
for position in 'abcdefghijklm':
parse = parser.parse(position)
self.assertEqual(parse.rule_name, 'note')
self.assertEqual(parse[0].rule_name, 'position')
self.assertEqual(parse[0].value, position)
def test_emptyBody(self):
parser = ParserGABC()
fileStr = 'attr1:value1;\n%%\n'
parse = parser.parse(fileStr)
self.assertEqual(parse[0].rule_name, 'header')
self.assertEqual(parse[1].rule_name, 'separator')
self.assertEqual(parse[2].rule_name, 'EOF')
def test_clefsFollowedByMusic(self):
# TODO remove test?
parser = ParserGABC(root='word')
s1, s2 = parser.parse('(c4)a(fg)')
_, clef, _ = s1
self.assertEqual(clef.rule_name, 'music')
self.assertEqual(clef[0].rule_name, 'clef')
def test_accidental(self):
parser = ParserGABC(root='music')
parse = parser.parse('fxgwf')
self.assertEqual(len(parse), 3)
self.assertEqual(parse[0].rule_name, 'alteration')
self.assertEqual(parse[1].rule_name, 'note')
self.assertEqual(parse[2].rule_name, 'note')
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_lyricTags(self):
parser = ParserGABC(root='text')
h, e, llo = parser.parse('H<i>e</i>llo')
self.assertEqual(h.value, 'H')
self.assertEqual(e.rule_name, 'tag')
self.assertEqual(e.value, '<i> | e | </i>')
self.assertEqual(llo.value, 'llo')
def test_clefTypes(self):
parser = ParserGABC(root='clef')
clefs = 'c1 c2 c3 c4 f1 f2 f3 f4 cb3'.split()
for clef_str in clefs:
parse = parser.parse(clef_str)
self.assertEqual(parse.rule_name, 'clef')
self.assertEqual(parse.value, clef_str)
def test_polyphonicAlterations(self):
parser = ParserGABC(root='music')
parse = parser.parse('f{ix}g')
n1, polyphony, n2 = parse
self.assertEqual(len(polyphony), 3)
self.assertEqual(polyphony.rule_name, 'polyphony')
self.assertEqual(polyphony[1].rule_name, 'alteration')
def test_macroReferences(self):
parser = ParserGABC(root='code')
codeExamples = ['[nm1]', '[gm1]', '[em1]']
for code in codeExamples:
parse = parser.parse(code)
self.assertEqual(parse.rule_name, 'code')
self.assertEqual(parse[1].rule_name, 'macro_reference')
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_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_wordsWithSpaces(self):
parser = ParserGABC(root='body')
parse = parser.parse('A(f)B (g) C(h)')
self.assertEqual(parse[0].rule_name, 'word')
self.assertEqual(parse[0].value, 'A | ( | f | ) | B | ( | g | )')
self.assertEqual(parse[1].rule_name, 'whitespace')
self.assertEqual(parse[2].rule_name, 'word')
self.assertEqual(parse[2].value, 'C | ( | h | )')
def test_bodyConfusedForHeader(self):
"""Tests that the body is not confused for the header when it contains
both colons and semicolons"""
parser = ParserGABC(root='file')
parse = parser.parse('%%\na :(g) (;)')
self.assertEqual(parse[0].value, '%%\n')
self.assertEqual(parse[1].rule_name, 'body')
self.assertEqual(parse[2].rule_name, 'EOF')
def test_spacesInMusic(self):
parser = ParserGABC(root='music')
parse = parser.parse('f , g')
n1, sp1, comma, sp2, n2 = parse
self.assertEqual(sp1.rule_name, 'spacer')
self.assertEqual(comma.rule_name, 'pausa')
self.assertEqual(comma.value, ',')
self.assertEqual(sp2.rule_name, 'spacer')
def test_file(self):
parser = ParserGABC()
fileStr = 'attr1:value1;\nattr2:value2;\n%%\n\na(f)b(g) c(h)\ni(j)'
parse = parser.parse(fileStr)
self.assertEqual(parse[0].rule_name, 'header')
self.assertEqual(parse[1].rule_name, 'separator')
self.assertEqual(parse[2].rule_name, 'body')
self.assertEqual(parse[3].rule_name, 'EOF')
def test_nonLyricsSpaces(self):
parser = ParserGABC(root='body')
for gabc in ["A(f) *(::)", "A(f) *(::)", "A(f) * (::)"]:
parse = parser.parse(gabc)
word1, _, bar, _ = parse
text, _, pausa, _ = bar[0]
self.assertEqual(text[0].rule_name, 'annotation')
self.assertEqual(text[0].value, '*')
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_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_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_clefChange(self):
# http://gregorio-project.github.io/gabc/details.html#endofline
parser = ParserGABC(root='music')
for gabc in ['z::c3', 'z0::c3']:
parse = parser.parse(gabc)
lineEnd, bar, clef = parse
self.assertEqual(lineEnd.rule_name, 'end_of_line')
self.assertEqual(bar.rule_name, 'pausa')
self.assertEqual(clef.rule_name, 'clef')