khodowany
+38
-14
@@ -7,15 +7,20 @@
|
||||
#include <rlgl.h>
|
||||
#include <luma.hpp>
|
||||
#include <vamp_zero/library.hpp>
|
||||
#include <vamp_zero/parse.hpp>
|
||||
#include <vamp_zero/score.hpp>
|
||||
|
||||
|
||||
namespace {
|
||||
|
||||
class score_view final : public luma::control {
|
||||
public:
|
||||
score_view(luma::application& app, vamp_zero::score_document score, std::string output, std::size_t page, std::bool_t& saved)
|
||||
: app_{app}, score_{std::move(score)}, output_{std::move(output)}, page_{page}, saved_{saved} {}
|
||||
auto measure(luma::draw_context&, luma::theme const&, luma::constraints) -> luma::size override { return {976,484}; }
|
||||
auto draw(luma::draw_context& context, luma::theme const&) const -> void override {
|
||||
score_view(luma::application &app, vamp_zero::score_document score, std::string output, std::size_t page, std::bool_t &saved)
|
||||
: app_{app}, score_{std::move(score)}, output_{std::move(output)}, page_{page}, saved_{saved} {}
|
||||
auto measure(luma::draw_context &, luma::theme const &, luma::constraints) -> luma::size override {
|
||||
return {976, 484};
|
||||
}
|
||||
auto draw(luma::draw_context &context, luma::theme const &) const -> void override {
|
||||
vamp_zero::draw_score_page(context, bounds(), score_, page_);
|
||||
rlDrawRenderBatchActive();
|
||||
auto image = LoadImageFromScreen();
|
||||
@@ -24,24 +29,43 @@ public:
|
||||
app_.request_stop();
|
||||
}
|
||||
private:
|
||||
luma::application& app_;
|
||||
luma::application &app_;
|
||||
vamp_zero::score_document score_;
|
||||
std::string output_;
|
||||
std::size_t page_;
|
||||
std::bool_t& saved_;
|
||||
std::bool_t &saved_;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
int main(int argc, std::char_t** argv) {
|
||||
if (argc < 3) { std::cerr << "Usage: vamp-render-score input.json output.png [page]\n"; return 2; }
|
||||
int main(int argc, std::char_t **argv) {
|
||||
if (argc < 3) {
|
||||
std::cerr << "Usage: vamp-render-score input.json output.png [page]\n";
|
||||
return 2;
|
||||
}
|
||||
auto page = std::size_t{};
|
||||
if (argc > 3) {
|
||||
auto parsed = vamp_zero::parse_integer<std::size_t>(argv[3], "page");
|
||||
if (!parsed) {
|
||||
std::cerr << parsed.error().describe() << '\n';
|
||||
return 2;
|
||||
}
|
||||
page = *parsed;
|
||||
}
|
||||
auto input = std::ifstream{argv[1]};
|
||||
auto json = std::string{std::istreambuf_iterator<std::char_t>{input},std::istreambuf_iterator<std::char_t>{}};
|
||||
auto score = vamp_zero::parse_score_document(json,argv[1]);
|
||||
if (!score) { std::cerr << score.error().describe() << '\n'; return 1; }
|
||||
auto app = luma::application{{.title="Notation Regression",.display={.width=976,.height=484,.target_fps=30,.fullscreen=false}}};
|
||||
auto json = std::string{std::istreambuf_iterator<std::char_t>{input}, std::istreambuf_iterator<std::char_t>{}};
|
||||
auto score = vamp_zero::parse_score_document(json, argv[1]);
|
||||
if (!score) {
|
||||
std::cerr << score.error().describe() << '\n';
|
||||
return 1;
|
||||
}
|
||||
auto app = luma::application{
|
||||
{.title = "Notation Regression", .display = {.width = 976, .height = 484, .target_fps = 30, .fullscreen = false}}};
|
||||
auto saved = std::bool_t{false};
|
||||
auto root = app.set_root(std::make_unique<score_view>(app,std::move(*score),argv[2],argc>3 ? std::stoul(argv[3]) : 0,saved));
|
||||
if (!root) return 1;
|
||||
auto root = app.set_root(std::make_unique<score_view>(app, std::move(*score), argv[2], page, saved));
|
||||
if (!root) {
|
||||
return 1;
|
||||
}
|
||||
auto ran = app.run();
|
||||
return ran && saved ? 0 : 1;
|
||||
}
|
||||
|
||||
+507
-243
File diff suppressed because it is too large
Load Diff
@@ -6,29 +6,29 @@ import types
|
||||
import unittest
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
|
||||
class BuildBootstrapTests(unittest.TestCase):
|
||||
def test_requirements_fingerprint_invalidates_cached_build_image(self):
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
spec = importlib.util.spec_from_file_location('vamp_bootstrap', root / 'modulus.py')
|
||||
bootstrap = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(bootstrap)
|
||||
digest = hashlib.sha256((root / 'tools/requirements.txt').read_bytes()).hexdigest()
|
||||
self.assertEqual(bootstrap.build_requirements_digest(), digest)
|
||||
self.assertIn(f'build-requirements="{digest}"', bootstrap.product_build_dockerfile())
|
||||
|
||||
package = types.ModuleType('modulus')
|
||||
cli = types.ModuleType('modulus.cli')
|
||||
package.cli = cli
|
||||
docker_run = Mock()
|
||||
cli.docker_run = docker_run
|
||||
cli.main = Mock(return_value=0)
|
||||
with patch.dict(sys.modules, {'modulus':package, 'modulus.cli':cli}), \
|
||||
patch.object(bootstrap, 'ensure_runtime') as prepare, \
|
||||
patch.object(bootstrap, 'runtime_ready', return_value=True), \
|
||||
patch.object(sys, 'path', list(sys.path)):
|
||||
self.assertEqual(bootstrap.delegate('clangd', []), 0)
|
||||
prepare.assert_not_called()
|
||||
docker_run.assert_not_called()
|
||||
cli.main.assert_called_once_with('clangd')
|
||||
self.assertIs(cli.docker_run, docker_run)
|
||||
def test_requirements_fingerprint_invalidates_cached_build_image(self):
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
spec = importlib.util.spec_from_file_location('vamp_bootstrap', root / 'modulus.py')
|
||||
bootstrap = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(bootstrap)
|
||||
digest = hashlib.sha256((root / 'tools/requirements.txt').read_bytes()).hexdigest()
|
||||
self.assertEqual(bootstrap.build_requirements_digest(), digest)
|
||||
self.assertIn(f'build-requirements="{digest}"', bootstrap.product_build_dockerfile())
|
||||
package = types.ModuleType('modulus')
|
||||
cli = types.ModuleType('modulus.cli')
|
||||
package.cli = cli
|
||||
docker_run = Mock()
|
||||
cli.docker_run = docker_run
|
||||
cli.main = Mock(return_value=0)
|
||||
for command in ('clangd', 'format'):
|
||||
with patch.dict(sys.modules, {'modulus': package, 'modulus.cli': cli}), \
|
||||
patch.object(bootstrap, 'ensure_runtime') as prepare, \
|
||||
patch.object(bootstrap, 'runtime_ready', return_value=True), \
|
||||
patch.object(sys, 'path', list(sys.path)):
|
||||
self.assertEqual(bootstrap.delegate(command, []), 0)
|
||||
prepare.assert_not_called()
|
||||
docker_run.assert_not_called()
|
||||
cli.main.assert_called_once_with(command)
|
||||
self.assertIs(cli.docker_run, docker_run)
|
||||
cli.main.reset_mock()
|
||||
|
||||
+109
-121
@@ -15,125 +15,113 @@ from generator.styles import BUILT_IN_STYLES, canonical_style
|
||||
from generator.transposition import concert_document, shift_pitch, transpose_document
|
||||
from tests.test_musicxml import parse, notes, xml_note, xml_score
|
||||
|
||||
|
||||
class MusicModelTests(unittest.TestCase):
|
||||
def test_chord_semantics_are_not_voicing_heuristics(self):
|
||||
cases = {'C':{0,4,7},'Cdim':{0,3,6},'Cdim7':{0,3,6,9},'Csus2':{0,2,7},
|
||||
'C7b5':{0,4,6,10},'G7b9':{7,11,2,5,8},'Fmaj7#11':{5,9,0,4,11}}
|
||||
for label, expected in cases.items():
|
||||
self.assertEqual(set(harmony.pitch_classes(harmony.parse_symbol(label))),expected,label)
|
||||
for label, essentials in [('G7b9',{11,5,8}),('C13',{4,10,9})]:
|
||||
pitches = pitches_for_voicing(label)
|
||||
self.assertTrue(essentials.issubset({pitch_number(p)%12 for p in pitches}),label)
|
||||
with self.assertRaises(ValueError):
|
||||
harmony.parse_symbol('Cunrecognised')
|
||||
|
||||
def test_transposition_preserves_spelling_octaves_modes(self):
|
||||
for p in ({'letter':'b','alter':1,'octave':4},{'letter':'c','alter':-1,'octave':4},{'letter':'f','alter':2,'octave':4}):
|
||||
self.assertEqual(shift_pitch(p,0,0),p)
|
||||
self.assertEqual(pitch_number(shift_pitch(p,1,2)),pitch_number(p)+2)
|
||||
source = parse(xml_score(xml_note(),attributes='<key><fifths>-3</fifths><mode>minor</mode></key>'))
|
||||
result = transpose_document(source,'D')
|
||||
self.assertEqual(result['metadata']['key_signature'],'D minor')
|
||||
self.assertEqual(result['metadata']['key']['alterations'],key_from_fifths(-1,'minor')['alterations'])
|
||||
|
||||
def test_additive_and_compound_grouping(self):
|
||||
self.assertEqual(beat_lengths({'groups':[{'beats':[3,2],'unit':8}]}),[Fraction(3,2),Fraction(1)])
|
||||
self.assertEqual(beat_lengths({'groups':[{'beats':[6],'unit':8}]}),[Fraction(3,2)]*2)
|
||||
self.assertEqual(beat_lengths({'groups':[{'beats':[3],'unit':4}]}),[Fraction(1)]*3)
|
||||
|
||||
def test_generated_rhythm_follows_mid_measure_meter(self):
|
||||
change = '<attributes><time><beats>6</beats><beat-type>8</beat-type></time></attributes>'
|
||||
source = parse(xml_score(xml_note(duration=1,kind='quarter')+change+xml_note(duration=3,kind='half',extra='<dot/>')))
|
||||
measure = source['staves'][0]['measures'][0]
|
||||
events = generated_voice(measure,'slash',None)
|
||||
self.assertEqual([fraction(n['onset']) for n in events],[0,1,Fraction(5,2)])
|
||||
self.assertEqual([fraction(n['duration']) for n in events],[1,Fraction(3,2),Fraction(3,2)])
|
||||
|
||||
def test_harmony_carry_uses_last_event_and_never_future_event(self):
|
||||
c = harmony.parse_symbol('C7') | {'onset':rational(0)}
|
||||
f = harmony.parse_symbol('F7') | {'onset':rational(2)}
|
||||
measures = [{'harmonies':[c,f]},{'harmonies':[]}]
|
||||
self.assertEqual(propagated_chords(measures),[None,f])
|
||||
self.assertIsNone(active_chord({'harmonies':[f]},Fraction(0),None))
|
||||
self.assertEqual(active_chord(measures[0],Fraction(1),None),c)
|
||||
|
||||
def test_tuplet_ratios_and_tie_links_validated(self):
|
||||
document = parse(xml_score(xml_note()))
|
||||
notes(document)[0]['pitches'][0]['tie_to'] = 'missing'
|
||||
with self.assertRaisesRegex(ValueError,'dangling tie'):
|
||||
validate_document(document)
|
||||
document = parse(xml_score(xml_note()))
|
||||
notes(document)[0]['duration'] = {'numerator':8,'denominator':2}
|
||||
with self.assertRaisesRegex(ValueError,'reduced'):
|
||||
validate_document(document)
|
||||
|
||||
def test_optional_turnaround_and_form(self):
|
||||
source = load_musicxml(Path('data/songs/it-could-happen-to-you.musicxml'))
|
||||
for part in ('acoustic','electric','vocal'):
|
||||
result = arrange_document(source,part)
|
||||
validate_document(result)
|
||||
measures = result['staves'][0]['measures']
|
||||
self.assertEqual(sum(bool(m.get('section_label')) for m in measures),7)
|
||||
self.assertFalse(measures[-1]['harmonies'])
|
||||
self.assertTrue(any(h for m in measures[:-1] for h in m['harmonies']))
|
||||
self.assertFalse(any('chord_optional' in h for m in measures for h in m['harmonies']))
|
||||
|
||||
def test_player_styles_preserved(self):
|
||||
self.assertEqual(len(BUILT_IN_STYLES),50)
|
||||
for text in ('Med.','Med. Swing','Medium','Medium Swing'):
|
||||
self.assertEqual(canonical_style(text),'Medium Swing')
|
||||
with self.assertRaises(ValueError):
|
||||
canonical_style('Unrecognised style')
|
||||
|
||||
def test_failure_preserves_generated_assets(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp)
|
||||
data = root/'data'
|
||||
(data/'songs').mkdir(parents=True)
|
||||
(data/'songs'/'bad.musicxml').write_text(xml_score(xml_note(duration=5)),encoding='utf-8')
|
||||
output = root/'output'
|
||||
output.mkdir()
|
||||
(output/'last-good').write_text('preserved')
|
||||
args = argparse.Namespace(data_dir=data,output_dir=output,static_assets_dir=Path('package/assets'),clean=True,check=False)
|
||||
with self.assertRaises(ValueError):
|
||||
generate_assets(args)
|
||||
self.assertEqual((output/'last-good').read_text(),'preserved')
|
||||
(data/'songs'/'bad.musicxml').write_text(xml_score(xml_note()),encoding='utf-8')
|
||||
args.check = True
|
||||
with self.assertRaisesRegex(ValueError,'summary'):
|
||||
generate_assets(args)
|
||||
self.assertEqual((output/'last-good').read_text(),'preserved')
|
||||
|
||||
def test_instrument_transposition_is_converted_once(self):
|
||||
source = parse(xml_score(xml_note(),attributes='<transpose><diatonic>-1</diatonic><chromatic>-2</chromatic></transpose>'))
|
||||
concert = concert_document(source)
|
||||
p = notes(concert)[0]['pitches'][0]
|
||||
self.assertEqual((p['letter'],p['alter'],p['octave']),('b',-1,3))
|
||||
self.assertEqual(concert_document(concert),concert)
|
||||
self.assertEqual(concert['metadata']['key_signature'],'Bb')
|
||||
|
||||
def test_deterministic_generation_and_removal(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
data,output = Path(temp)/'data',Path(temp)/'output'
|
||||
(data/'songs').mkdir(parents=True)
|
||||
source = data/'songs'/'fixture.musicxml'
|
||||
source.write_text(xml_score(xml_note()),encoding='utf-8')
|
||||
args = argparse.Namespace(data_dir=data,output_dir=output,static_assets_dir=Path('package/assets'),clean=True,check=False)
|
||||
generate_assets(args)
|
||||
first = {p.relative_to(output):p.read_bytes() for p in output.rglob('*') if p.is_file()}
|
||||
generate_assets(args)
|
||||
self.assertEqual(first,{p.relative_to(output):p.read_bytes() for p in output.rglob('*') if p.is_file()})
|
||||
source.unlink()
|
||||
generate_assets(args)
|
||||
self.assertFalse(list(output.rglob('*.json')))
|
||||
|
||||
def test_pickup_tie_survives_vocal_restoration(self):
|
||||
source = xml_score(xml_note(duration=1,kind='quarter',extra='<tie type="start"/>'),implicit=True)
|
||||
source = source.replace('</measure></part>','</measure><measure number="2">'+xml_note(extra='<tie type="stop"/>')+'</measure></part>')
|
||||
result = arrange_document(parse(source),'vocal')
|
||||
validate_document(result)
|
||||
measures = result['staves'][0]['measures']
|
||||
start = measures[0]['voices'][0]['notes'][-1]['pitches'][0]
|
||||
end = measures[1]['voices'][0]['notes'][0]['pitches'][0]
|
||||
self.assertEqual(start['tie_to'],end['id'])
|
||||
def test_chord_semantics_are_not_voicing_heuristics(self):
|
||||
cases = {'C': {0, 4, 7}, 'Cdim': {0, 3, 6}, 'Cdim7': {0, 3, 6, 9}, 'Csus2': {0, 2, 7},
|
||||
'C7b5': {0, 4, 6, 10}, 'G7b9': {7, 11, 2, 5, 8}, 'Fmaj7#11': {5, 9, 0, 4, 11}}
|
||||
for label, expected in cases.items():
|
||||
self.assertEqual(set(harmony.pitch_classes(harmony.parse_symbol(label))), expected, label)
|
||||
for label, essentials in [('G7b9', {11, 5, 8}), ('C13', {4, 10, 9})]:
|
||||
pitches = pitches_for_voicing(label)
|
||||
self.assertTrue(essentials.issubset({pitch_number(p) % 12 for p in pitches}), label)
|
||||
with self.assertRaises(ValueError):
|
||||
harmony.parse_symbol('Cunrecognised')
|
||||
def test_transposition_preserves_spelling_octaves_modes(self):
|
||||
for p in ({'letter': 'b', 'alter': 1, 'octave': 4}, {'letter': 'c', 'alter': -1, 'octave': 4}, {'letter': 'f', 'alter': 2, 'octave': 4}):
|
||||
self.assertEqual(shift_pitch(p, 0, 0), p)
|
||||
self.assertEqual(pitch_number(shift_pitch(p, 1, 2)), pitch_number(p) + 2)
|
||||
source = parse(xml_score(xml_note(), attributes='<key><fifths>-3</fifths><mode>minor</mode></key>'))
|
||||
result = transpose_document(source, 'D')
|
||||
self.assertEqual(result['metadata']['key_signature'], 'D minor')
|
||||
self.assertEqual(result['metadata']['key']['alterations'], key_from_fifths(-1, 'minor')['alterations'])
|
||||
def test_additive_and_compound_grouping(self):
|
||||
self.assertEqual(beat_lengths({'groups': [{'beats': [3, 2], 'unit': 8}]}), [Fraction(3, 2), Fraction(1)])
|
||||
self.assertEqual(beat_lengths({'groups': [{'beats': [6], 'unit': 8}]}), [Fraction(3, 2)] * 2)
|
||||
self.assertEqual(beat_lengths({'groups': [{'beats': [3], 'unit': 4}]}), [Fraction(1)] * 3)
|
||||
def test_generated_rhythm_follows_mid_measure_meter(self):
|
||||
change = '<attributes><time><beats>6</beats><beat-type>8</beat-type></time></attributes>'
|
||||
source = parse(xml_score(xml_note(duration=1, kind='quarter') + change + xml_note(duration=3, kind='half', extra='<dot/>')))
|
||||
measure = source['staves'][0]['measures'][0]
|
||||
events = generated_voice(measure, 'slash', None)
|
||||
self.assertEqual([fraction(n['onset']) for n in events], [0, 1, Fraction(5, 2)])
|
||||
self.assertEqual([fraction(n['duration']) for n in events], [1, Fraction(3, 2), Fraction(3, 2)])
|
||||
def test_harmony_carry_uses_last_event_and_never_future_event(self):
|
||||
c = harmony.parse_symbol('C7') | {'onset': rational(0)}
|
||||
f = harmony.parse_symbol('F7') | {'onset': rational(2)}
|
||||
measures = [{'harmonies': [c, f]}, {'harmonies': []}]
|
||||
self.assertEqual(propagated_chords(measures), [None, f])
|
||||
self.assertIsNone(active_chord({'harmonies': [f]}, Fraction(0), None))
|
||||
self.assertEqual(active_chord(measures[0], Fraction(1), None), c)
|
||||
def test_tuplet_ratios_and_tie_links_validated(self):
|
||||
document = parse(xml_score(xml_note()))
|
||||
notes(document)[0]['pitches'][0]['tie_to'] = 'missing'
|
||||
with self.assertRaisesRegex(ValueError, 'dangling tie'):
|
||||
validate_document(document)
|
||||
document = parse(xml_score(xml_note()))
|
||||
notes(document)[0]['duration'] = {'numerator': 8, 'denominator': 2}
|
||||
with self.assertRaisesRegex(ValueError, 'reduced'):
|
||||
validate_document(document)
|
||||
def test_optional_turnaround_and_form(self):
|
||||
source = load_musicxml(Path('data/songs/it-could-happen-to-you.xml'))
|
||||
for part in ('acoustic', 'electric', 'vocal'):
|
||||
result = arrange_document(source, part)
|
||||
validate_document(result)
|
||||
measures = result['staves'][0]['measures']
|
||||
self.assertEqual(sum(bool(m.get('section_label')) for m in measures), 7)
|
||||
self.assertFalse(measures[-1]['harmonies'])
|
||||
self.assertTrue(any(h for m in measures[:-1] for h in m['harmonies']))
|
||||
self.assertFalse(any('chord_optional' in h for m in measures for h in m['harmonies']))
|
||||
def test_player_styles_preserved(self):
|
||||
self.assertEqual(len(BUILT_IN_STYLES), 50)
|
||||
for text in ('Med.', 'Med. Swing', 'Medium', 'Medium Swing'):
|
||||
self.assertEqual(canonical_style(text), 'Medium Swing')
|
||||
with self.assertRaises(ValueError):
|
||||
canonical_style('Unrecognised style')
|
||||
def test_failure_preserves_generated_assets(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp)
|
||||
data = root / 'data'
|
||||
(data / 'songs').mkdir(parents=True)
|
||||
(data / 'songs' / 'bad.xml').write_text(xml_score(xml_note(duration=5)), encoding='utf-8')
|
||||
output = root / 'output'
|
||||
output.mkdir()
|
||||
(output / 'last-good').write_text('preserved')
|
||||
args = argparse.Namespace(data_dir=data, output_dir=output, static_assets_dir=Path('package/assets'), clean=True, check=False)
|
||||
with self.assertRaises(ValueError):
|
||||
generate_assets(args)
|
||||
self.assertEqual((output / 'last-good').read_text(), 'preserved')
|
||||
(data / 'songs' / 'bad.xml').write_text(xml_score(xml_note()), encoding='utf-8')
|
||||
args.check = True
|
||||
with self.assertRaisesRegex(ValueError, 'summary'):
|
||||
generate_assets(args)
|
||||
self.assertEqual((output / 'last-good').read_text(), 'preserved')
|
||||
def test_instrument_transposition_is_converted_once(self):
|
||||
source = parse(xml_score(xml_note(), attributes='<transpose><diatonic>-1</diatonic><chromatic>-2</chromatic></transpose>'))
|
||||
concert = concert_document(source)
|
||||
p = notes(concert)[0]['pitches'][0]
|
||||
self.assertEqual((p['letter'], p['alter'], p['octave']), ('b', -1, 3))
|
||||
self.assertEqual(concert_document(concert), concert)
|
||||
self.assertEqual(concert['metadata']['key_signature'], 'Bb')
|
||||
def test_deterministic_generation_and_removal(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
data, output = Path(temp) / 'data', Path(temp) / 'output'
|
||||
(data / 'songs').mkdir(parents=True)
|
||||
source = data / 'songs' / 'fixture.xml'
|
||||
source.write_text(xml_score(xml_note()), encoding='utf-8')
|
||||
args = argparse.Namespace(data_dir=data, output_dir=output, static_assets_dir=Path('package/assets'), clean=True, check=False)
|
||||
generate_assets(args)
|
||||
first = {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()}
|
||||
generate_assets(args)
|
||||
self.assertEqual(first, {p.relative_to(output): p.read_bytes() for p in output.rglob('*') if p.is_file()})
|
||||
source.unlink()
|
||||
generate_assets(args)
|
||||
self.assertFalse(list(output.rglob('*.json')))
|
||||
def test_pickup_tie_survives_vocal_restoration(self):
|
||||
source = xml_score(xml_note(duration=1, kind='quarter', extra='<tie type="start"/>'), implicit=True)
|
||||
source = source.replace('</measure></part>', '</measure><measure number="2">' + xml_note(extra='<tie type="stop"/>') + '</measure></part>')
|
||||
result = arrange_document(parse(source), 'vocal')
|
||||
validate_document(result)
|
||||
measures = result['staves'][0]['measures']
|
||||
start = measures[0]['voices'][0]['notes'][-1]['pitches'][0]
|
||||
end = measures[1]['voices'][0]['notes'][0]['pitches'][0]
|
||||
self.assertEqual(start['tie_to'], end['id'])
|
||||
|
||||
+158
-171
@@ -6,183 +6,170 @@ import unittest
|
||||
from generator.musicxml import MusicXMLError, load_musicxml
|
||||
from generator.model import NOTE_TYPES, TYPE_LENGTHS, fraction, pitch_number
|
||||
|
||||
|
||||
def xml_score(content, attributes='', *, divisions=1, implicit=False):
|
||||
return ('<?xml version="1.0"?>'
|
||||
'<score-partwise version="4.0"><work><work-title>Fixture</work-title></work>'
|
||||
'<part-list><score-part id="P1"><part-name>Lead</part-name></score-part></part-list>'
|
||||
f'<part id="P1"><measure number="1" implicit="{"yes" if implicit else "no"}">'
|
||||
f'<attributes><divisions>{divisions}</divisions><key><fifths>0</fifths></key>'
|
||||
'<time><beats>4</beats><beat-type>4</beat-type></time>'
|
||||
f'<clef><sign>G</sign><line>2</line></clef>{attributes}</attributes>'
|
||||
f'{content}</measure></part></score-partwise>')
|
||||
|
||||
return ('<?xml version="1.0"?>'
|
||||
'<score-partwise version="4.0"><work><work-title>Fixture</work-title></work>'
|
||||
'<part-list><score-part id="P1"><part-name>Lead</part-name></score-part></part-list>'
|
||||
f'<part id="P1"><measure number="1" implicit="{"yes" if implicit else "no"}">'
|
||||
f'<attributes><divisions>{divisions}</divisions><key><fifths>0</fifths></key>'
|
||||
'<time><beats>4</beats><beat-type>4</beat-type></time>'
|
||||
f'<clef><sign>G</sign><line>2</line></clef>{attributes}</attributes>'
|
||||
f'{content}</measure></part></score-partwise>')
|
||||
|
||||
def xml_note(step='C', duration=4, kind='whole', extra='', prefix='', alter=0, octave=4):
|
||||
return (f'<note>{prefix}<pitch><step>{step}</step><alter>{alter}</alter><octave>{octave}</octave></pitch>'
|
||||
f'<duration>{duration}</duration><type>{kind}</type>{extra}</note>')
|
||||
|
||||
return (f'<note>{prefix}<pitch><step>{step}</step><alter>{alter}</alter><octave>{octave}</octave></pitch>'
|
||||
f'<duration>{duration}</duration><type>{kind}</type>{extra}</note>')
|
||||
|
||||
def parse(text):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = Path(directory) / 'fixture.musicxml'
|
||||
path.write_text(text, encoding='utf-8')
|
||||
return load_musicxml(path)
|
||||
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = Path(directory) / 'fixture.xml'
|
||||
path.write_text(text, encoding='utf-8')
|
||||
return load_musicxml(path)
|
||||
|
||||
def notes(document, measure=0):
|
||||
return document['staves'][0]['measures'][measure]['voices'][0]['notes']
|
||||
|
||||
return document['staves'][0]['measures'][measure]['voices'][0]['notes']
|
||||
|
||||
class MusicXMLTests(unittest.TestCase):
|
||||
def test_regression_fixture(self):
|
||||
score = load_musicxml(Path('tests/fixtures/notation.musicxml'))
|
||||
self.assertEqual(len(score['staves'][0]['measures']),4)
|
||||
self.assertEqual(len(score['staves'][0]['octave_shifts']),1)
|
||||
|
||||
def test_catalogue_imports(self):
|
||||
sources = sorted(Path('data').rglob('*.musicxml'))
|
||||
self.assertEqual(len(sources), 6)
|
||||
for path in sources:
|
||||
with self.subTest(path=path):
|
||||
self.assertEqual(load_musicxml(path)['schema_version'], 2)
|
||||
|
||||
def test_all_written_values_and_dots(self):
|
||||
for kind in NOTE_TYPES:
|
||||
for dots in (0, 1, 2, 3):
|
||||
value = TYPE_LENGTHS[kind] * (2-Fraction(1, 2**dots))
|
||||
score = parse(xml_score(xml_note(duration=value.numerator, kind=kind, extra='<dot/>'*dots), divisions=value.denominator, implicit=True))
|
||||
self.assertEqual(fraction(notes(score)[0]['duration']), value)
|
||||
self.assertEqual(notes(score)[0]['written'], {'type':kind, 'dots':dots})
|
||||
|
||||
def test_divisions_do_not_change_music(self):
|
||||
a = parse(xml_score(xml_note(duration=4)))
|
||||
b = parse(xml_score(xml_note(duration=1920), divisions=480))
|
||||
self.assertEqual(a, b)
|
||||
|
||||
def test_doctype_allowed_but_entities_rejected(self):
|
||||
source = xml_score(xml_note())
|
||||
source = source.replace('<score-partwise', '<!DOCTYPE score-partwise SYSTEM "https://invalid.test/partwise.dtd"><score-partwise', 1)
|
||||
self.assertEqual(parse(source)['schema_version'], 2)
|
||||
malicious = xml_score(xml_note()).replace('<score-partwise', '<!DOCTYPE score-partwise [<!ENTITY secret SYSTEM "file:///etc/passwd">]><score-partwise',1)
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(malicious)
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse('<score-partwise')
|
||||
|
||||
def test_harmony_inside_sustained_note_remains_independent(self):
|
||||
h = '<harmony><root><root-step>F</root-step></root><kind>major</kind><offset>-2</offset></harmony>'
|
||||
score = parse(xml_score(xml_note()+h))
|
||||
self.assertEqual(len(notes(score)), 1)
|
||||
self.assertEqual(fraction(score['staves'][0]['measures'][0]['harmonies'][0]['onset']), 2)
|
||||
|
||||
def test_partial_chord_ties_and_unequal_tones(self):
|
||||
source = xml_note(duration=2,kind='half',extra='<tie type="start"/>')
|
||||
source += xml_note('E',1,'quarter',prefix='<chord/>')
|
||||
source += xml_note(duration=2,kind='half',extra='<tie type="stop"/>')
|
||||
source += xml_note('G',2,'half',prefix='<chord/>')
|
||||
result = notes(parse(xml_score(source)))
|
||||
self.assertEqual(fraction(result[0]['pitches'][1]['duration']), 1)
|
||||
self.assertEqual(result[0]['pitches'][0]['tie_to'], result[1]['pitches'][0]['id'])
|
||||
self.assertNotIn('tie_to', result[0]['pitches'][1])
|
||||
|
||||
def test_grace_cue_and_measured_tremolo(self):
|
||||
grace = '<note><grace slash="yes"/><pitch><step>D</step><octave>4</octave></pitch><type>16th</type></note>'
|
||||
regular = xml_note(extra='<notations><ornaments><tremolo type="single">3</tremolo></ornaments></notations>', prefix='<cue/>')
|
||||
result = notes(parse(xml_score(grace+regular)))
|
||||
self.assertEqual(fraction(result[0]['duration']), 0)
|
||||
self.assertTrue(result[0]['grace']['slash'])
|
||||
self.assertTrue(result[1]['cue'])
|
||||
self.assertEqual(result[1]['tremolo']['marks'], 3)
|
||||
|
||||
def test_exact_quintuplets(self):
|
||||
content = ''
|
||||
for i in range(5):
|
||||
tuplet = '<tuplet type="start"/>' if i==0 else '<tuplet type="stop"/>' if i==4 else ''
|
||||
extra = '<time-modification><actual-notes>5</actual-notes><normal-notes>4</normal-notes></time-modification>'
|
||||
extra += '<notations>'+tuplet+'</notations>'
|
||||
content += xml_note(duration=4, kind='quarter',extra=extra)
|
||||
result = parse(xml_score(content,divisions=5))
|
||||
self.assertEqual(sum(fraction(n['duration']) for n in notes(result)),4)
|
||||
self.assertTrue(all(fraction(n['duration'])==Fraction(4,5) for n in notes(result)))
|
||||
self.assertEqual(result['staves'][0]['tuplets'][0]['note_count'],5)
|
||||
|
||||
def test_inconsistent_written_timing_is_rejected(self):
|
||||
modulation = '<time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>'
|
||||
with self.assertRaisesRegex(MusicXMLError,'disagrees with written duration'):
|
||||
parse(xml_score(xml_note(extra=modulation)))
|
||||
with self.assertRaisesRegex(MusicXMLError,'disagrees with written duration'):
|
||||
parse(xml_score(xml_note(kind='half')))
|
||||
|
||||
def test_paired_tremolo_timing(self):
|
||||
modulation = '<time-modification><actual-notes>2</actual-notes><normal-notes>1</normal-notes></time-modification>'
|
||||
content = ''.join(xml_note(step,2,'whole',extra=modulation+f'<notations><ornaments><tremolo type="{action}">3</tremolo></ornaments></notations>')
|
||||
for step,action in [('C','start'),('G','stop')])
|
||||
result = notes(parse(xml_score(content)))
|
||||
self.assertEqual(result[0]['tremolo']['partner'],result[1]['id'])
|
||||
self.assertEqual(fraction(result[0]['duration']),2)
|
||||
|
||||
def test_mid_measure_clef_and_key_changes(self):
|
||||
change = '<attributes><key><fifths>-3</fifths><mode>minor</mode></key><clef><sign>C</sign><line>3</line></clef></attributes>'
|
||||
result = parse(xml_score(xml_note(duration=2,kind='half')+change+xml_note(duration=2,kind='half')))
|
||||
attr = result['staves'][0]['measures'][0]['attributes'][0]
|
||||
self.assertEqual(fraction(attr['onset']),2)
|
||||
self.assertEqual(attr['key']['mode'],'minor')
|
||||
self.assertEqual(attr['clef']['sign'],'C')
|
||||
|
||||
def test_optional_marker_contract(self):
|
||||
marker = '<direction><direction-type><words>vamp:optional-chord</words></direction-type></direction>'
|
||||
h = '<harmony><root><root-step>C</root-step></root><kind>major</kind></harmony>'
|
||||
score = parse(xml_score(marker+h+xml_note()))
|
||||
self.assertTrue(score['staves'][0]['measures'][0]['harmonies'][0]['chord_optional'])
|
||||
for content in (marker+xml_note(),marker+marker+h+xml_note(),marker.replace('optional-chord','unknown')+xml_note()):
|
||||
with self.assertRaisesRegex(MusicXMLError,'measure 1'):
|
||||
parse(xml_score(content))
|
||||
|
||||
def test_rejects_musical_content_outside_contract(self):
|
||||
extras = ['<notations><slur type="start"/></notations>', '<notations><articulations><accent/></articulations></notations>',
|
||||
'<voice>2</voice><staff>2</staff>', '<pitch><unpitched/></pitch>',
|
||||
'<notations><ornaments><trill-mark/></ornaments></notations>']
|
||||
for extra in extras:
|
||||
with self.subTest(extra=extra), self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(extra=extra)))
|
||||
for extra in ('<barline><repeat direction="backward"/></barline>', '<backup><duration>4</duration></backup>',
|
||||
'<direction><direction-type><dynamics><ff/></dynamics></direction-type></direction>'):
|
||||
with self.subTest(extra=extra), self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note()+extra))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(alter='0.5')))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(extra='<tie type="stop"/>')))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(duration=5)))
|
||||
|
||||
def test_b_sharp_c_flat_preserve_octave(self):
|
||||
b = notes(parse(xml_score(xml_note('B',alter=1))))[0]['pitches'][0]
|
||||
c = notes(parse(xml_score(xml_note('C',alter=-1))))[0]['pitches'][0]
|
||||
self.assertEqual(pitch_number(b),72)
|
||||
self.assertEqual(pitch_number(c),59)
|
||||
|
||||
def test_musicxml_degree_alterations_are_relative(self):
|
||||
h = '<harmony><root><root-step>C</root-step></root><kind>minor</kind><degree><degree-value>3</degree-value><degree-alter>1</degree-alter><degree-type>alter</degree-type></degree></harmony>'
|
||||
from generator.harmony import degrees
|
||||
score = parse(xml_score(h+xml_note()))
|
||||
self.assertEqual(degrees(score['staves'][0]['measures'][0]['harmonies'][0])[3],0)
|
||||
h = h.replace('<kind>minor</kind>','<kind text="maj7">minor</kind>')
|
||||
with self.assertRaisesRegex(MusicXMLError,'contradictory'):
|
||||
parse(xml_score(h+xml_note()))
|
||||
|
||||
def test_nested_and_cross_bar_tuplets(self):
|
||||
modulation = '<time-modification><actual-notes>9</actual-notes><normal-notes>4</normal-notes></time-modification>'
|
||||
def tuplet(number,action):
|
||||
details = '<tuplet-actual><tuplet-number>3</tuplet-number></tuplet-actual><tuplet-normal><tuplet-number>2</tuplet-number></tuplet-normal>' if action=='start' else ''
|
||||
return f'<tuplet number="{number}" type="{action}">{details}</tuplet>'
|
||||
first = xml_note(duration=4,kind='quarter',extra=modulation+'<notations>'+tuplet(1,'start')+tuplet(2,'start')+'</notations>')
|
||||
last = xml_note(duration=4,kind='quarter',extra=modulation+'<notations>'+tuplet(2,'stop')+tuplet(1,'stop')+'</notations>')
|
||||
text = xml_score(first,divisions=9,implicit=True)
|
||||
text = text.replace('</measure></part>', '</measure><measure number="2" implicit="yes">'+last+'</measure></part>')
|
||||
result = parse(text)
|
||||
spans = result['staves'][0]['tuplets']
|
||||
self.assertEqual([t['depth'] for t in spans],[0,1])
|
||||
self.assertEqual(fraction(notes(result,1)[0]['duration']),Fraction(4,9))
|
||||
self.assertTrue(all(t['end']==notes(result,1)[0]['id'] for t in spans))
|
||||
def test_measure_sound_tempo_matches_direction_sound(self):
|
||||
sound = '<sound tempo="120"/>'
|
||||
direct = parse(xml_score(sound + xml_note()))
|
||||
direction = parse(xml_score('<direction>' + sound + '</direction>' + xml_note()))
|
||||
self.assertEqual(direct, direction)
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score('<sound tempo="0"/>' + xml_note()))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score('<sound dacapo="yes"/>' + xml_note()))
|
||||
def test_regression_fixture(self):
|
||||
score = load_musicxml(Path('tests/fixtures/notation.xml'))
|
||||
self.assertEqual(len(score['staves'][0]['measures']), 4)
|
||||
self.assertEqual(len(score['staves'][0]['octave_shifts']), 1)
|
||||
def test_catalogue_imports(self):
|
||||
sources = sorted(Path('data').rglob('*.xml'))
|
||||
self.assertEqual(len(sources), 6)
|
||||
for path in sources:
|
||||
with self.subTest(path=path):
|
||||
self.assertEqual(load_musicxml(path)['schema_version'], 2)
|
||||
def test_all_written_values_and_dots(self):
|
||||
for kind in NOTE_TYPES:
|
||||
for dots in (0, 1, 2, 3):
|
||||
value = TYPE_LENGTHS[kind] * (2 - Fraction(1, 2**dots))
|
||||
score = parse(xml_score(xml_note(duration=value.numerator, kind=kind, extra='<dot/>' * dots), divisions=value.denominator, implicit=True))
|
||||
self.assertEqual(fraction(notes(score)[0]['duration']), value)
|
||||
self.assertEqual(notes(score)[0]['written'], {'type': kind, 'dots': dots})
|
||||
def test_divisions_do_not_change_music(self):
|
||||
a = parse(xml_score(xml_note(duration=4)))
|
||||
b = parse(xml_score(xml_note(duration=1920), divisions=480))
|
||||
self.assertEqual(a, b)
|
||||
def test_doctype_allowed_but_entities_rejected(self):
|
||||
source = xml_score(xml_note())
|
||||
source = source.replace('<score-partwise', '<!DOCTYPE score-partwise SYSTEM "https://invalid.test/partwise.dtd"><score-partwise', 1)
|
||||
self.assertEqual(parse(source)['schema_version'], 2)
|
||||
malicious = xml_score(xml_note()).replace('<score-partwise', '<!DOCTYPE score-partwise [<!ENTITY secret SYSTEM "file:///etc/passwd">]><score-partwise', 1)
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(malicious)
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse('<score-partwise')
|
||||
def test_harmony_inside_sustained_note_remains_independent(self):
|
||||
h = '<harmony><root><root-step>F</root-step></root><kind>major</kind><offset>-2</offset></harmony>'
|
||||
score = parse(xml_score(xml_note() + h))
|
||||
self.assertEqual(len(notes(score)), 1)
|
||||
self.assertEqual(fraction(score['staves'][0]['measures'][0]['harmonies'][0]['onset']), 2)
|
||||
def test_partial_chord_ties_and_unequal_tones(self):
|
||||
source = xml_note(duration=2, kind='half', extra='<tie type="start"/>')
|
||||
source += xml_note('E', 1, 'quarter', prefix='<chord/>')
|
||||
source += xml_note(duration=2, kind='half', extra='<tie type="stop"/>')
|
||||
source += xml_note('G', 2, 'half', prefix='<chord/>')
|
||||
result = notes(parse(xml_score(source)))
|
||||
self.assertEqual(fraction(result[0]['pitches'][1]['duration']), 1)
|
||||
self.assertEqual(result[0]['pitches'][0]['tie_to'], result[1]['pitches'][0]['id'])
|
||||
self.assertNotIn('tie_to', result[0]['pitches'][1])
|
||||
def test_grace_cue_and_measured_tremolo(self):
|
||||
grace = '<note><grace slash="yes"/><pitch><step>D</step><octave>4</octave></pitch><type>16th</type></note>'
|
||||
regular = xml_note(extra='<notations><ornaments><tremolo type="single">3</tremolo></ornaments></notations>', prefix='<cue/>')
|
||||
result = notes(parse(xml_score(grace + regular)))
|
||||
self.assertEqual(fraction(result[0]['duration']), 0)
|
||||
self.assertTrue(result[0]['grace']['slash'])
|
||||
self.assertTrue(result[1]['cue'])
|
||||
self.assertEqual(result[1]['tremolo']['marks'], 3)
|
||||
def test_exact_quintuplets(self):
|
||||
content = ''
|
||||
for i in range(5):
|
||||
tuplet = '<tuplet type="start"/>' if i == 0 else '<tuplet type="stop"/>' if i == 4 else ''
|
||||
extra = '<time-modification><actual-notes>5</actual-notes><normal-notes>4</normal-notes></time-modification>'
|
||||
extra += '<notations>' + tuplet + '</notations>'
|
||||
content += xml_note(duration=4, kind='quarter', extra=extra)
|
||||
result = parse(xml_score(content, divisions=5))
|
||||
self.assertEqual(sum(fraction(n['duration']) for n in notes(result)), 4)
|
||||
self.assertTrue(all(fraction(n['duration']) == Fraction(4, 5) for n in notes(result)))
|
||||
self.assertEqual(result['staves'][0]['tuplets'][0]['note_count'], 5)
|
||||
def test_inconsistent_written_timing_is_rejected(self):
|
||||
modulation = '<time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>'
|
||||
with self.assertRaisesRegex(MusicXMLError, 'disagrees with written duration'):
|
||||
parse(xml_score(xml_note(extra=modulation)))
|
||||
with self.assertRaisesRegex(MusicXMLError, 'disagrees with written duration'):
|
||||
parse(xml_score(xml_note(kind='half')))
|
||||
def test_paired_tremolo_timing(self):
|
||||
modulation = '<time-modification><actual-notes>2</actual-notes><normal-notes>1</normal-notes></time-modification>'
|
||||
content = ''.join(xml_note(step, 2, 'whole', extra=modulation + f'<notations><ornaments><tremolo type="{action}">3</tremolo></ornaments></notations>')
|
||||
for step, action in [('C', 'start'), ('G', 'stop')])
|
||||
result = notes(parse(xml_score(content)))
|
||||
self.assertEqual(result[0]['tremolo']['partner'], result[1]['id'])
|
||||
self.assertEqual(fraction(result[0]['duration']), 2)
|
||||
def test_mid_measure_clef_and_key_changes(self):
|
||||
change = '<attributes><key><fifths>-3</fifths><mode>minor</mode></key><clef><sign>C</sign><line>3</line></clef></attributes>'
|
||||
result = parse(xml_score(xml_note(duration=2, kind='half') + change + xml_note(duration=2, kind='half')))
|
||||
attr = result['staves'][0]['measures'][0]['attributes'][0]
|
||||
self.assertEqual(fraction(attr['onset']), 2)
|
||||
self.assertEqual(attr['key']['mode'], 'minor')
|
||||
self.assertEqual(attr['clef']['sign'], 'C')
|
||||
def test_optional_marker_contract(self):
|
||||
marker = '<direction><direction-type><words>vamp:optional-chord</words></direction-type></direction>'
|
||||
h = '<harmony><root><root-step>C</root-step></root><kind>major</kind></harmony>'
|
||||
score = parse(xml_score(marker + h + xml_note()))
|
||||
self.assertTrue(score['staves'][0]['measures'][0]['harmonies'][0]['chord_optional'])
|
||||
for content in (marker + xml_note(), marker + marker + h + xml_note(), marker.replace('optional-chord', 'unknown') + xml_note()):
|
||||
with self.assertRaisesRegex(MusicXMLError, 'measure 1'):
|
||||
parse(xml_score(content))
|
||||
def test_rejects_musical_content_outside_contract(self):
|
||||
extras = ['<notations><slur type="start"/></notations>', '<notations><articulations><accent/></articulations></notations>',
|
||||
'<voice>2</voice><staff>2</staff>', '<pitch><unpitched/></pitch>',
|
||||
'<notations><ornaments><trill-mark/></ornaments></notations>']
|
||||
for extra in extras:
|
||||
with self.subTest(extra=extra), self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(extra=extra)))
|
||||
for extra in ('<barline><repeat direction="backward"/></barline>', '<backup><duration>4</duration></backup>', '<direction><direction-type><dynamics><ff/></dynamics></direction-type></direction>'):
|
||||
with self.subTest(extra=extra), self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note() + extra))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(alter='0.5')))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(extra='<tie type="stop"/>')))
|
||||
with self.assertRaises(MusicXMLError):
|
||||
parse(xml_score(xml_note(duration=5)))
|
||||
def test_b_sharp_c_flat_preserve_octave(self):
|
||||
b = notes(parse(xml_score(xml_note('B', alter=1))))[0]['pitches'][0]
|
||||
c = notes(parse(xml_score(xml_note('C', alter=-1))))[0]['pitches'][0]
|
||||
self.assertEqual(pitch_number(b), 72)
|
||||
self.assertEqual(pitch_number(c), 59)
|
||||
def test_musicxml_degree_alterations_are_relative(self):
|
||||
h = '<harmony><root><root-step>C</root-step></root><kind>minor</kind><degree><degree-value>3</degree-value><degree-alter>1</degree-alter><degree-type>alter</degree-type></degree></harmony>'
|
||||
from generator.harmony import degrees
|
||||
score = parse(xml_score(h + xml_note()))
|
||||
self.assertEqual(degrees(score['staves'][0]['measures'][0]['harmonies'][0])[3], 0)
|
||||
h = h.replace('<kind>minor</kind>', '<kind text="maj7">minor</kind>')
|
||||
with self.assertRaisesRegex(MusicXMLError, 'contradictory'):
|
||||
parse(xml_score(h + xml_note()))
|
||||
def test_nested_and_cross_bar_tuplets(self):
|
||||
modulation = '<time-modification><actual-notes>9</actual-notes><normal-notes>4</normal-notes></time-modification>'
|
||||
def tuplet(number, action):
|
||||
details = '<tuplet-actual><tuplet-number>3</tuplet-number></tuplet-actual><tuplet-normal><tuplet-number>2</tuplet-number></tuplet-normal>' if action == 'start' else ''
|
||||
return f'<tuplet number="{number}" type="{action}">{details}</tuplet>'
|
||||
first = xml_note(duration=4, kind='quarter', extra=modulation + '<notations>' + tuplet(1, 'start') + tuplet(2, 'start') + '</notations>')
|
||||
last = xml_note(duration=4, kind='quarter', extra=modulation + '<notations>' + tuplet(2, 'stop') + tuplet(1, 'stop') + '</notations>')
|
||||
text = xml_score(first, divisions=9, implicit=True)
|
||||
text = text.replace('</measure></part>', '</measure><measure number="2" implicit="yes">' + last + '</measure></part>')
|
||||
result = parse(text)
|
||||
spans = result['staves'][0]['tuplets']
|
||||
self.assertEqual([t['depth'] for t in spans], [0, 1])
|
||||
self.assertEqual(fraction(notes(result, 1)[0]['duration']), Fraction(4, 9))
|
||||
self.assertTrue(all(t['end'] == notes(result, 1)[0]['id'] for t in spans))
|
||||
|
||||
@@ -11,7 +11,6 @@ from generator.__main__ import copy_runtime_fonts
|
||||
from tools import generate_pico_font
|
||||
from tools import generate_score_metrics
|
||||
|
||||
|
||||
class FontAssetsTests(unittest.TestCase):
|
||||
def test_score_metrics_use_fixed_width_codepoints(self):
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
@@ -21,12 +20,10 @@ class FontAssetsTests(unittest.TestCase):
|
||||
content = output.read_text(encoding="ascii")
|
||||
self.assertIn("#include <cstdint>", content)
|
||||
self.assertIn("std::int32_t codepoint", content)
|
||||
|
||||
def test_font_generator_requires_kerning_backend(self):
|
||||
with unittest.mock.patch.object(generate_pico_font.features, "check_feature", return_value=False):
|
||||
with self.assertRaisesRegex(RuntimeError, "Raqm"):
|
||||
generate_pico_font.generate()
|
||||
|
||||
def test_runtime_fonts_exclude_unused_assets(self):
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
@@ -34,7 +31,6 @@ class FontAssetsTests(unittest.TestCase):
|
||||
copy_runtime_fonts(root / "package/assets", output)
|
||||
files = {path.name for path in (output / "fonts/petaluma").iterdir()}
|
||||
self.assertEqual(files, {"Petaluma.otf", "PetalumaScript.otf", "OFL.txt"})
|
||||
|
||||
def test_font_generator_uses_explicit_build_output(self):
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
|
||||
Reference in New Issue
Block a user