211 lines
7.0 KiB
Python
211 lines
7.0 KiB
Python
""" Test cases for the parser """
|
|
import pytest
|
|
from ziffers import zparse, get_items
|
|
|
|
# pylint: disable=missing-function-docstring, line-too-long, invalid-name
|
|
|
|
def test_can_parse():
|
|
expressions = [
|
|
"0 1 2 3 4 5 6 7 8 9 T E",
|
|
"023 i iv iv^min",
|
|
"[1 [2 3]]",
|
|
"(1 (1,3) 1..3)",
|
|
"_^ q _qe^3 qww_4 _123 <1 2>",
|
|
"q _2 _ 3 ^ 343",
|
|
"2 qe2 e4",
|
|
"q 2 <3 343>",
|
|
"q (2 <3 343 (3 4)>)",
|
|
"? 1 2",
|
|
"(? 2 ? 4)+(1,4)",
|
|
"(1 2 <2 3>)+(0 1 2)"
|
|
]
|
|
results = []
|
|
for expression in expressions:
|
|
try:
|
|
print(f"Parsing expression: {expression}")
|
|
result = zparse(expression)
|
|
results.append(True)
|
|
except Exception as e:
|
|
print(e)
|
|
results.append(False)
|
|
|
|
# Return true if all the results are true (succesfully parsed)
|
|
print(results)
|
|
assert all(results)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern",
|
|
[
|
|
"1 2 3",
|
|
"q3 e4 s5",
|
|
],
|
|
)
|
|
def test_parsing_text(pattern: str):
|
|
assert zparse(pattern).text == pattern
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("1 2 3", [1, 2, 3]),
|
|
("q2 eq3", [2, 3]),
|
|
],
|
|
)
|
|
def test_pitch_classes(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"pitch_class") == expected*2
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("__6 _0 _1 _2 _3 _4 _5 _6 0 1 2 3 4 5 6 ^0 ^1 ^2 ^3 ^4 ^5 ^6 ^^0", [-2, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2]),
|
|
("_ 1 _2 <3>3 ^^4", [-1, -2, 3, 1]),
|
|
("^ 1 ^1 3 _2 ^^1 _2 <-1> 2 ^4", [1, 2, 1, 0, 3, 0, -1, 0]),
|
|
]
|
|
)
|
|
def test_pitch_octaves(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"octave") == expected*2
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("w [1 [2 3]]", [0.5, 0.25, 0.25]),
|
|
("1.0 [1 [2 3]] 4 [3 [4 5]]", [0.5, 0.25, 0.25, 1.0, 0.5, 0.25, 0.25]),
|
|
("0.5 (0 0.25 3)+1", [0.5, 0.25]),
|
|
("[0 2 <2 8>:2 4] 0", [0.05, 0.05, 0.05, 0.05, 0.05, 0.25])
|
|
]
|
|
)
|
|
def test_subdivisions(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"duration") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("[: 1 [: 2 :] 3 :]", [62, 64, 64, 65, 62, 64, 64, 65]),
|
|
("(: 1 (: 2 :) 3 :)", [62, 64, 64, 65, 62, 64, 64, 65]),
|
|
("(1 2:2 3):2", [62, 64, 64, 65, 62, 64, 64, 65]),
|
|
("1:4",[62,62,62,62])
|
|
]
|
|
)
|
|
def test_repeats(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"note") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("[: 3 [2 4] :]", [0.25, 0.125, 0.125, 0.25, 0.125, 0.125]),
|
|
("[: 1 [2 [5 6]] 3 [2 4] :]", [0.25, 0.125, 0.0625, 0.0625, 0.25, 0.125, 0.125, 0.25, 0.125, 0.0625, 0.0625, 0.25, 0.125, 0.125]),
|
|
("(: 3 [2 4] :)", [0.25, 0.125, 0.125, 0.25, 0.125, 0.125]),
|
|
("(: 1 [2 [5 6]] 3 [2 4] :)", [0.25, 0.125, 0.0625, 0.0625, 0.25, 0.125, 0.125, 0.25, 0.125, 0.0625, 0.0625, 0.25, 0.125, 0.125]),
|
|
("(3 [2 4]):2", [0.25, 0.125, 0.125, 0.25, 0.125, 0.125]),
|
|
("(1 [2 [5 6]] 3 [2 4]):2", [0.25, 0.125, 0.0625, 0.0625, 0.25, 0.125, 0.125, 0.25, 0.125, 0.0625, 0.0625, 0.25, 0.125, 0.125]),
|
|
|
|
]
|
|
)
|
|
def test_repeat_durations(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"duration") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("0 [0 2] 0", [0.25, 0.125, 0.125, 0.25, 0.25, 0.125, 0.125, 0.25, 0.25, 0.125, 0.125, 0.25]),
|
|
("w 0 [0 [1 [2 3]] 0] 9", [1.0, 0.3333333333333333, 0.16666666666666666, 0.08333333333333333, 0.08333333333333333, 0.3333333333333333, 1.0, 1.0, 0.3333333333333333, 0.16666666666666666, 0.08333333333333333, 0.08333333333333333]),
|
|
("1.0 0 [[2 3] [3 5]] 4", [1.0, 0.25, 0.25, 0.25, 0.25, 1.0, 1.0, 0.25, 0.25, 0.25, 0.25, 1.0]),
|
|
("2.0 0 [1[2[3[4 5]6]7]8] 9", [2.0, 0.6666666666666666, 0.2222222222222222, 0.07407407407407407, 0.037037037037037035, 0.037037037037037035, 0.07407407407407407, 0.2222222222222222, 0.6666666666666666, 2.0, 2.0, 0.6666666666666666])
|
|
|
|
]
|
|
)
|
|
def test_looping_durations(pattern: str, expected: list):
|
|
parsed = zparse(pattern)
|
|
durations = []
|
|
for i in range(12):
|
|
durations.append(parsed[i].duration)
|
|
assert durations == expected
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("e 1 | 3 | h 3 | e3 | 4", [0.125,0.25,0.5,0.125,0.25])
|
|
]
|
|
)
|
|
def test_measure_durations(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"duration") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("^ 1 | _ 3 | ^3 | 3 | _4", [1,-1,1,0,-1])
|
|
]
|
|
)
|
|
def test_measure_octaves(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"octave") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("e r qr r q r", [0.125, 0.25, 0.125, 0.25])
|
|
]
|
|
)
|
|
def test_rest(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"duration") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("-3..9 1..9", [55, 57, 59, 60, 62, 64, 65, 67, 69, 71, 72, 74, 76, 62, 64, 65, 67, 69, 71, 72, 74, 76])
|
|
]
|
|
)
|
|
def test_ranges(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"note") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("0 1 2 3", [None, 60, 62, 64])
|
|
]
|
|
)
|
|
def test_degree_notation(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern, degrees=True),len(expected)*2,"note") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("i ii iii iv v vi vii", [[60, 64, 67], [62, 65, 69], [64, 67, 71], [65, 69, 72], [67, 71, 74], [69, 72, 76], [71, 74, 77]])
|
|
]
|
|
)
|
|
def test_romans(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"note") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("[: i vi v :]", [[0, 2, 4], [5, 0, 2], [4, 6, 1], [0, 2, 4], [5, 0, 2], [4, 6, 1]]),
|
|
("i ii iii iv v vi vii", [[0, 2, 4], [1, 3, 5], [2, 4, 6], [3, 5, 0], [4, 6, 1], [5, 0, 2], [6, 1, 3]]),
|
|
("i^7 i^min iv^6", [[0, 2, 4, 6], [0, 2, 4], [3, 5, 0, 1]])
|
|
]
|
|
)
|
|
def test_romans_pcs(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"pitches") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("(0 1 2 3 r)+(1)", [1,2,3,4,None]),
|
|
("(0 1 2 3 r)-(0 1 4)", [0, -1, -2, -3, None, 1, 0, -1, -2, None, 4, 3, 2, 1, None])
|
|
]
|
|
)
|
|
def test_operations(pattern: str, expected: list):
|
|
assert get_items(zparse(pattern),len(expected)*2,"pitch_class") == expected*2
|
|
|
|
@pytest.mark.parametrize(
|
|
"pattern,expected",
|
|
[
|
|
("(i)+<0 1 2>", [[60, 64, 67], [62, 65, 69], [64, 67, 71], [60, 64, 67]]),
|
|
("(i)+<0 <1 2>>",[[60, 64, 67], [62, 65, 69], [60, 64, 67], [64, 67, 71]])
|
|
]
|
|
)
|
|
def test_cycles(pattern: str, expected: list):
|
|
zparse.cache_clear() # Clear cache for cycles
|
|
assert get_items(zparse(pattern),4,"note") == expected
|