khodo/product-vamp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
44e100985a43ce60fe0d9320621bc86faef50644
product-vamp/tests/test.cpp
T
khodowany 44e100985a Integral Types
2026-09-12 10:11:50 -07:00

1263 lines
53 KiB
C++
Raw Blame History

#include <test.hpp>
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstddef>
#include <cstdio>
#include <cstdint>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <future>
#include <initializer_list>
#include <limits>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <variant>
#include <vector>
#include <boost/asio/co_spawn.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/use_future.hpp>
#include <boost/json/object.hpp>
#include <boost/json/parse.hpp>
#include <boost/json/serialize.hpp>
#include <boost/json/array.hpp>
#include <noto.hpp>
#include <vamp_protocol/page_control.hpp>
#include <vamp_zero/config.hpp>
#include <vamp_pico/http_client.hpp>
#include <vamp_zero/database.hpp>
#include <vamp_zero/library.hpp>
#include <vamp_zero/page_control.hpp>
#include <vamp_zero/score.hpp>
#include <vamp_zero/types.hpp>
namespace {
constexpr auto layout_any_index = std::numeric_limits<std::size_t>::max();
auto pitch(std::char_t letter, std::string accidental, std::int32_t octave = 4) -> vamp_zero::score_pitch {
return {
.letter = letter,
.octave = octave,
.accidental = std::move(accidental),
};
}
auto note(
std::initializer_list<vamp_zero::score_pitch> pitches,
std::bool_t tie_from_previous = false,
std::string notehead = {},
std::bool_t hidden = false
) -> vamp_zero::score_note {
return {
.kind = "note",
.hidden = hidden,
.duration_ticks = 4096,
.display_ticks = 4096,
.notehead = std::move(notehead),
.tie_from_previous = tie_from_previous,
.pitches = std::vector<vamp_zero::score_pitch>{pitches},
};
}
auto note_with_ticks(std::initializer_list<vamp_zero::score_pitch> pitches, std::int64_t ticks) -> vamp_zero::score_note {
auto value = note(pitches);
value.duration_ticks = ticks;
value.display_ticks = ticks;
return value;
}
auto rest(std::initializer_list<vamp_zero::score_pitch> pitches) -> vamp_zero::score_note {
return {
.kind = "rest",
.duration_ticks = 4096,
.display_ticks = 4096,
.pitches = std::vector<vamp_zero::score_pitch>{pitches},
};
}
auto mark_name(vamp_zero::score_accidental_mark mark) -> std::string {
switch (mark) {
case vamp_zero::score_accidental_mark::NONE:
return "none";
case vamp_zero::score_accidental_mark::FLAT:
return "flat";
case vamp_zero::score_accidental_mark::NATURAL:
return "natural";
case vamp_zero::score_accidental_mark::SHARP:
return "sharp";
}
return {};
}
auto mark_names(std::vector<vamp_zero::score_accidental_mark> const& marks) -> std::vector<std::string> {
auto names = std::vector<std::string>{};
names.reserve(marks.size());
for (auto mark : marks) {
names.push_back(mark_name(mark));
}
return names;
}
void expect_marks(std::vector<vamp_zero::score_accidental_mark> const& marks, std::initializer_list<std::string_view> expected) {
auto actual_names = mark_names(marks);
BOOST_REQUIRE_EQUAL(actual_names.size(), expected.size());
auto index = std::size_t{};
for (auto name : expected) {
BOOST_TEST(actual_names[index] == std::string{name});
++index;
}
}
auto score_with_measure(vamp_zero::score_measure measure, std::string key_signature = "C", std::string time_signature = "4/4", std::string clef = "treble") -> vamp_zero::score_document {
if (measure.key_signature.empty()) {
measure.key_signature = key_signature;
}
if (measure.time_signature.empty()) {
measure.time_signature = time_signature;
}
return {
.title = "Layout Tune",
.composer = "Composer",
.key_signature = std::move(key_signature),
.time_signature = std::move(time_signature),
.clef = std::move(clef),
.part = "Lead",
.measures = {std::move(measure)},
};
}
auto score_with_notes(std::vector<vamp_zero::score_note> notes, std::string key_signature = "C", std::string time_signature = "4/4", std::string clef = "treble") -> vamp_zero::score_document {
auto measure = vamp_zero::score_measure{
.time_signature = time_signature,
.key_signature = key_signature,
.notes = std::move(notes),
};
return score_with_measure(std::move(measure), std::move(key_signature), std::move(time_signature), std::move(clef));
}
auto layout_items(
vamp_zero::score_page_layout const& layout,
vamp_zero::score_layout_item_role role,
std::size_t system_index = layout_any_index,
std::size_t measure_index = layout_any_index,
std::size_t note_index = layout_any_index
) -> std::vector<vamp_zero::score_layout_item const*> {
auto result = std::vector<vamp_zero::score_layout_item const*>{};
for (auto const& item : layout.items) {
if (item.role != role) {
continue;
}
if (system_index != layout_any_index && item.system_index != system_index) {
continue;
}
if (measure_index != layout_any_index && item.measure_index != measure_index) {
continue;
}
if (note_index != layout_any_index && item.note_index != note_index) {
continue;
}
result.push_back(&item);
}
return result;
}
auto center_x(vamp_zero::score_layout_item const& item) -> std::float32_t {
return item.bounds.x + item.bounds.width * 0.5F;
}
auto center_y(vamp_zero::score_layout_item const& item) -> std::float32_t {
return item.bounds.y + item.bounds.height * 0.5F;
}
auto right_edge(vamp_zero::score_layout_item const& item) -> std::float32_t {
return item.bounds.x + item.bounds.width;
}
auto left_edge(vamp_zero::score_layout_item const& item) -> std::float32_t {
return item.bounds.x;
}
auto bottom_edge(vamp_zero::score_layout_item const& item) -> std::float32_t {
return item.bounds.y + item.bounds.height;
}
auto near(std::float32_t left, std::float32_t right) -> std::bool_t {
return std::abs(left - right) < 0.02F;
}
void expect_up_stem_connected(vamp_zero::score_layout_item const& head, vamp_zero::score_layout_item const& stem, std::float32_t staff_spacing) {
auto const overlap = right_edge(head) - stem.from.x;
BOOST_TEST(overlap >= staff_spacing * 0.12F);
BOOST_TEST(overlap <= staff_spacing * 0.45F);
BOOST_TEST(stem.from.x > left_edge(head));
BOOST_TEST(stem.from.y > head.bounds.y);
BOOST_TEST(stem.from.y < bottom_edge(head));
BOOST_TEST(stem.to.y < stem.from.y);
}
void expect_down_stem_connected(vamp_zero::score_layout_item const& head, vamp_zero::score_layout_item const& stem, std::float32_t staff_spacing) {
auto const overlap = stem.from.x - left_edge(head);
BOOST_TEST(overlap >= staff_spacing * 0.12F);
BOOST_TEST(overlap <= staff_spacing * 0.45F);
BOOST_TEST(stem.from.x < right_edge(head));
BOOST_TEST(stem.from.y > head.bounds.y);
BOOST_TEST(stem.from.y < bottom_edge(head));
BOOST_TEST(stem.to.y > stem.from.y);
}
auto test_database_config(std::filesystem::path const& path) -> vamp_zero::database_config {
return {
.path = path.string(),
};
}
auto run_ensure_database(vamp_zero::database_config config) -> std::expected<void, modulus::error> {
auto io = boost::asio::io_context{};
auto future = boost::asio::co_spawn(io, vamp_zero::async_ensure_database(io.get_executor(), std::move(config)), boost::asio::use_future);
io.run();
return future.get();
}
auto run_import(vamp_zero::database_config config, std::filesystem::path const& assets_path) -> std::expected<void, modulus::error> {
auto io = boost::asio::io_context{};
auto future = boost::asio::co_spawn(io, vamp_zero::async_import_catalogs(io.get_executor(), std::move(config), assets_path.string()), boost::asio::use_future);
io.run();
return future.get();
}
auto query_database(std::filesystem::path const& path, std::string sql, std::vector<noto::sqlite_value> params = {}) -> std::expected<noto::query_result, modulus::error> {
auto io = boost::asio::io_context{};
auto future = boost::asio::co_spawn(
io,
[executor = io.get_executor(), path = path.string(), sql = std::move(sql), params = std::move(params)]() mutable -> boost::asio::awaitable<std::expected<noto::query_result, modulus::error>> {
auto config = noto::file_connection_config(path, "product-vamp-test");
config.foreign_keys = true;
auto connection = noto::connection{executor, std::move(config)};
auto connected = co_await connection.async_connect();
if (!connected) {
co_return std::unexpected(connected.error());
}
auto selected = co_await connection.async_execute(std::move(sql), std::move(params));
auto closed = co_await connection.async_close();
if (!selected) {
co_return std::unexpected(selected.error());
}
if (!closed) {
co_return std::unexpected(closed.error());
}
co_return selected;
},
boost::asio::use_future);
io.run();
return future.get();
}
auto text_value(noto::sqlite_value const& value) -> std::string {
auto text = std::get_if<std::string>(&value.value);
return text == nullptr ? std::string{} : *text;
}
auto integer_value(noto::sqlite_value const& value) -> std::int64_t {
auto integer = std::get_if<std::int64_t>(&value.value);
return integer == nullptr ? 0 : *integer;
}
auto has_value(noto::query_result const& result, std::size_t column, std::string_view expected) -> std::bool_t {
return std::any_of(result.rows.begin(), result.rows.end(), [&](auto const& row) {
return row.size() > column && text_value(row[column]) == expected;
});
}
auto score_asset_json(std::string title, std::string key = "C") -> std::string {
auto value = boost::json::parse(R"json({
"schema_version":2,
"metadata":{"title":"Fixture","composer":"Composer","key_signature":"C","time_signature":"4/4"},
"staves":[{"id":"staff-lead","name":"Lead","role":"lead","clef":{"sign":"G","line":2,"octave_change":0},
"measures":[{"id":"measure-1","duration":{"numerator":4,"denominator":1},"key_signature":"C","time_signature":"4/4",
"key":{"alterations":[0,0,0,0,0,0,0]},"meter":{"groups":[{"beats":[4],"unit":4}]},
"clef":{"sign":"G","line":2,"octave_change":0},
"voices":[{"id":"voice-1","notes":[{"id":"note-1","kind":"note",
"onset":{"numerator":0,"denominator":1},"duration":{"numerator":4,"denominator":1},
"written":{"type":"whole","dots":0},
"pitches":[{"id":"pitch-1","letter":"c","octave":4,"alter":0,
"duration":{"numerator":4,"denominator":1},"written":{"type":"whole","dots":0}}]}]}]}]}]
})json");
auto& root = value.as_object();
root["metadata"].as_object()["title"] = title;
root["metadata"].as_object()["key_signature"] = key;
root["staves"].as_array()[0].as_object()["measures"].as_array()[0].as_object()["key_signature"] = key;
return boost::json::serialize(value);
}
auto navigation_state() -> vamp_zero::app_state {
auto part = vamp_zero::library_part{
.id = "part-lead",
.title = "Navigation Tune",
.composer = "Composer",
.key_signature = "C",
.part = "Lead",
.source_path = "navigation.json",
.source_json = score_asset_json("Navigation Tune"),
.measure_count = 1,
.total_pages = 2,
};
auto variant = vamp_zero::practice_exercise::score_variant{
.id = "exercise-c",
.key_signature = "C",
.source_path = "exercise.json",
.source_json = score_asset_json("Exercise"),
.measure_count = 1,
.total_pages = 1,
};
auto exercise = vamp_zero::practice_exercise{
.id = "exercise-1",
.practice_type_id = "scale",
.practice_type_title = "Scales",
.lesson_group_id = "lesson-1",
.lesson_group_title = "Major",
.title = "C Major",
.composer = "Composer",
.key_signature = "C",
.source_path = "exercise.json",
.source_json = score_asset_json("Exercise"),
.measure_count = 1,
.total_pages = 1,
.variants = {variant},
};
return vamp_zero::app_state{
.performance = {
.parts = {part},
.groups = {{
.title = part.title,
.composer = part.composer,
.parts = {part},
}},
},
.practice = {
.exercises = {exercise},
.types = {{
.id = "scale",
.title = "Scales",
.lesson_groups = {{
.id = "lesson-1",
.title = "Major",
.exercises = {exercise},
}},
}},
},
};
}
void write_text(std::filesystem::path const& path, std::string const& text) {
std::filesystem::create_directories(path.parent_path());
auto output = std::ofstream{path, std::ios::binary | std::ios::trunc};
output << text;
}
}
BOOST_AUTO_TEST_CASE(product_vamp_audio_config_parses_defaults_and_values) {
auto defaults = vamp_zero::parse_config(boost::json::parse(R"json({})json"));
BOOST_REQUIRE(defaults);
BOOST_TEST(defaults->audio.enabled);
BOOST_TEST(!defaults->audio.track_enabled);
BOOST_TEST(!defaults->audio.metronome_enabled);
BOOST_TEST(defaults->audio.metronome_bpm == 120U);
BOOST_TEST(defaults->audio.metronome_min_bpm == 40U);
BOOST_TEST(defaults->audio.metronome_max_bpm == 240U);
BOOST_TEST(defaults->audio.metronome_step == 5U);
auto parsed = vamp_zero::parse_config(boost::json::parse(R"json({
"audio": {
"enabled": false,
"track_enabled": true,
"metronome_enabled": true,
"metronome_bpm": 90,
"metronome_min_bpm": 50,
"metronome_max_bpm": 180,
"metronome_step": 10,
"beats_per_bar": 3,
"master_volume": 0.5,
"metronome_volume": 0.25
}
})json"));
BOOST_REQUIRE(parsed);
BOOST_TEST(!parsed->audio.enabled);
BOOST_TEST(parsed->audio.track_enabled);
BOOST_TEST(parsed->audio.metronome_enabled);
BOOST_TEST(parsed->audio.metronome_bpm == 90U);
BOOST_TEST(parsed->audio.metronome_min_bpm == 50U);
BOOST_TEST(parsed->audio.metronome_max_bpm == 180U);
BOOST_TEST(parsed->audio.metronome_step == 10U);
BOOST_TEST(parsed->audio.beats_per_bar == 3U);
BOOST_TEST(parsed->audio.master_volume == 0.5F);
BOOST_TEST(parsed->audio.metronome_volume == 0.25F);
}
BOOST_AUTO_TEST_CASE(product_vamp_audio_config_rejects_invalid_tempo_range) {
auto parsed = vamp_zero::parse_config(boost::json::parse(R"json({
"audio": {
"metronome_bpm": 120,
"metronome_min_bpm": 160,
"metronome_max_bpm": 80
}
})json"));
BOOST_TEST(!parsed);
}
BOOST_AUTO_TEST_CASE(main_menu_toggles_audio_settings_and_edits_tempo) {
auto state = navigation_state();
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
BOOST_TEST(state.selected_main_menu_index == 2U);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(state.audio.track_enabled);
BOOST_TEST(static_cast<std::int32_t>(state.mode) == static_cast<std::int32_t>(vamp_zero::app_mode::MAIN_MENU));
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
BOOST_TEST(state.selected_main_menu_index == 3U);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(state.audio.metronome_enabled);
BOOST_TEST(static_cast<std::int32_t>(state.mode) == static_cast<std::int32_t>(vamp_zero::app_mode::MAIN_MENU));
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
BOOST_TEST(state.selected_main_menu_index == 4U);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(state.audio.tempo_editing);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
BOOST_TEST(state.audio.metronome_bpm == 125U);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::PREVIOUS);
BOOST_TEST(state.audio.metronome_bpm == 120U);
for (auto index = std::int32_t{}; index < 40; ++index) {
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::PREVIOUS);
}
BOOST_TEST(state.audio.metronome_bpm == 40U);
for (auto index = std::int32_t{}; index < 80; ++index) {
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
}
BOOST_TEST(state.audio.metronome_bpm == 240U);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(!state.audio.tempo_editing);
}
BOOST_AUTO_TEST_CASE(audio_status_json_reports_menu_settings) {
auto state = navigation_state();
state.audio.track_enabled = true;
state.audio.metronome_enabled = true;
state.audio.metronome_bpm = 135;
state.audio.tempo_editing = true;
auto status = vamp_zero::app_status_json(state).as_object();
auto const& audio = status.at("audio").as_object();
BOOST_TEST(audio.at("track_enabled").as_bool());
BOOST_TEST(audio.at("metronome_enabled").as_bool());
BOOST_TEST(audio.at("metronome_bpm").as_uint64() == 135U);
BOOST_TEST(audio.at("metronome_min_bpm").as_uint64() == 40U);
BOOST_TEST(audio.at("metronome_max_bpm").as_uint64() == 240U);
BOOST_TEST(audio.at("metronome_step").as_uint64() == 5U);
BOOST_TEST(audio.at("tempo_editing").as_bool());
}
BOOST_AUTO_TEST_CASE(main_menu_metronome_setting_survives_score_selection) {
auto state = navigation_state();
state.audio.metronome_enabled = true;
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(static_cast<std::int32_t>(state.mode) == static_cast<std::int32_t>(vamp_zero::app_mode::PERFORMANCE_SONG_MENU));
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(static_cast<std::int32_t>(state.mode) == static_cast<std::int32_t>(vamp_zero::app_mode::PERFORMANCE_PART_MENU));
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
BOOST_TEST(static_cast<std::int32_t>(state.mode) == static_cast<std::int32_t>(vamp_zero::app_mode::PERFORMANCE_SCORE));
BOOST_TEST(state.audio.metronome_enabled);
BOOST_TEST(!state.audio.tempo_editing);
}
BOOST_AUTO_TEST_CASE(score_parser_preserves_notation_preamble) {
auto parsed = vamp_zero::parse_score_document(score_asset_json("Standard Tune", "Eb"), "standard-tune.json");
BOOST_REQUIRE(static_cast<std::bool_t>(parsed));
BOOST_TEST(parsed->title == "Standard Tune");
BOOST_TEST(parsed->composer == "Composer");
BOOST_TEST(parsed->key_signature == "Eb");
BOOST_TEST(parsed->time_signature == "4/4");
BOOST_TEST(parsed->clef == "G:2:0");
BOOST_TEST(parsed->part == "Lead");
BOOST_REQUIRE_EQUAL(parsed->measures.size(), 1U);
BOOST_TEST(parsed->measures.front().duration.numerator == 4);
BOOST_TEST(parsed->measures.front().notes.front().written.type == "whole");
}
BOOST_AUTO_TEST_CASE(score_parser_loads_the_generated_catalogue) {
auto count = std::size_t{};
for (auto const& entry : std::filesystem::recursive_directory_iterator{VAMP_TEST_ASSETS_DIR}) {
if (entry.path().extension() != ".json") continue;
auto input = std::ifstream{entry.path()};
auto json = std::string{std::istreambuf_iterator<std::char_t>{input}, std::istreambuf_iterator<std::char_t>{}};
auto parsed = vamp_zero::parse_score_document(json, entry.path().string());
BOOST_TEST_CONTEXT(entry.path().string()) {
BOOST_REQUIRE(parsed.has_value());
BOOST_TEST(vamp_zero::score_page_count(*parsed) > 0U);
}
++count;
}
BOOST_TEST(count > 0U);
}
BOOST_AUTO_TEST_CASE(score_parser_rejects_old_schema_and_extra_voices) {
BOOST_TEST(!vamp_zero::parse_score_document(R"({"metadata":{"title":"Old"},"staves":[]})").has_value());
auto source = boost::json::parse(score_asset_json("Fixture"));
auto& voices = source.as_object()["staves"].as_array()[0].as_object()["measures"].as_array()[0].as_object()["voices"].as_array();
auto copy = voices[0];
voices.push_back(copy);
BOOST_TEST(!vamp_zero::parse_score_document(boost::json::serialize(source)).has_value());
}
BOOST_AUTO_TEST_CASE(score_parser_rejects_invalid_rational_and_dangling_tie) {
auto source = boost::json::parse(score_asset_json("Fixture"));
auto& n = source.as_object()["staves"].as_array()[0].as_object()["measures"].as_array()[0].as_object()["voices"].as_array()[0].as_object()["notes"].as_array()[0].as_object();
n["duration"].as_object()["denominator"] = 0;
BOOST_TEST(!vamp_zero::parse_score_document(boost::json::serialize(source)).has_value());
n["duration"].as_object()["denominator"] = 1;
n["pitches"].as_array()[0].as_object()["tie_to"] = "missing";
BOOST_TEST(!vamp_zero::parse_score_document(boost::json::serialize(source)).has_value());
}
BOOST_AUTO_TEST_CASE(score_layout_supports_all_written_durations_and_multiple_dots) {
auto names = std::vector<std::string>{"maxima","long","breve","whole","half","quarter","eighth","16th","32nd","64th","128th","256th","512th","1024th"};
for (auto const& name : names) {
auto n = note({pitch('c',"n",4)});
n.written = {.type=name,.dots=2};
n.pitches.front().written = n.written;
auto layout = vamp_zero::layout_score_page({.x=0,.y=0,.width=976,.height=484},score_with_notes({n}),0);
auto dots = layout_items(layout,vamp_zero::score_layout_item_role::DOT,0,0,0);
BOOST_TEST(dots.size()==2U);
for (auto const& item : layout.items) if (item.kind == vamp_zero::score_layout_item_kind::GLYPH) {
BOOST_TEST(item.bounds.width > 0);
BOOST_TEST(item.bounds.height > 0);
}
n.kind = "rest";
n.pitches.clear();
layout = vamp_zero::layout_score_page({.x=0,.y=0,.width=976,.height=484},score_with_notes({n}),0);
auto rests = layout_items(layout,vamp_zero::score_layout_item_role::REST,0,0,0);
BOOST_REQUIRE_EQUAL(rests.size(),1U);
BOOST_TEST(rests[0]->bounds.width > 0);
BOOST_TEST(rests[0]->bounds.height > 0);
}
}
BOOST_AUTO_TEST_CASE(score_layout_paginates_dense_measures_without_losing_events) {
auto notes = std::vector<vamp_zero::score_note>{};
for (auto i = std::int32_t{}; i < 128; ++i) {
auto n = note_with_ticks({pitch('c',"#",4)},128);
n.written = {.type="128th"};
n.duration = {1,32};
n.onset = {i,32};
notes.push_back(n);
}
auto score = score_with_notes(notes);
auto total = std::size_t{};
auto pages = vamp_zero::score_page_count(score);
BOOST_TEST(pages>1U);
for (auto page = std::size_t{}; page < pages; ++page) {
auto layout = vamp_zero::layout_score_page({.x=0,.y=0,.width=976,.height=484},score,page);
for (auto const& item : layout.items) if (item.role == vamp_zero::score_layout_item_role::NOTEHEAD) {
++total;
BOOST_TEST(item.bounds.x >= 0);
BOOST_TEST(item.bounds.x+item.bounds.width <= 976);
BOOST_TEST(item.bounds.y >= 0);
BOOST_TEST(item.bounds.y+item.bounds.height <= 484);
}
}
BOOST_TEST(total==notes.size());
}
BOOST_AUTO_TEST_CASE(score_layout_uses_independent_harmony_onsets) {
auto source = boost::json::parse(score_asset_json("Fixture"));
auto& m = source.as_object()["staves"].as_array()[0].as_object()["measures"].as_array()[0].as_object();
m["harmonies"] = boost::json::parse(R"([{"id":"h1","onset":{"numerator":2,"denominator":1},"kind":"major","symbol":"F"}])");
auto score = vamp_zero::parse_score_document(boost::json::serialize(source));
BOOST_REQUIRE(score.has_value());
auto layout = vamp_zero::layout_score_page({.x=0,.y=0,.width=976,.height=484},*score,0);
auto heads = layout_items(layout,vamp_zero::score_layout_item_role::NOTEHEAD,0,0);
auto chords = layout_items(layout,vamp_zero::score_layout_item_role::CHORD_SYMBOL,0,0);
BOOST_REQUIRE_EQUAL(heads.size(),1U);
BOOST_REQUIRE_EQUAL(chords.size(),1U);
BOOST_TEST(chords[0]->origin.x > heads[0]->origin.x);
}
BOOST_AUTO_TEST_CASE(score_layout_keeps_section_measure_and_harmony_labels_separate) {
auto score = score_with_notes({note({pitch('e', "n", 5)})});
score.measures[0].section_label = "Melody";
score.measures[0].harmonies.push_back({"h1", {0,1}, "Cmaj7", "major-seventh"});
for (auto bounds : {luma::rect{.x=0,.y=0,.width=976,.height=484}, luma::rect{.x=0,.y=0,.width=480,.height=320}}) {
auto layout = vamp_zero::layout_score_page(bounds, score, 0);
auto sections = layout_items(layout, vamp_zero::score_layout_item_role::SECTION_LABEL);
auto numbers = layout_items(layout, vamp_zero::score_layout_item_role::MEASURE_NUMBER);
auto chords = layout_items(layout, vamp_zero::score_layout_item_role::CHORD_SYMBOL);
BOOST_REQUIRE_EQUAL(sections.size(), 1U);
BOOST_REQUIRE_EQUAL(numbers.size(), 1U);
BOOST_REQUIRE_EQUAL(chords.size(), 1U);
BOOST_TEST(sections[0]->bounds.y >= 0);
BOOST_TEST(bottom_edge(*sections[0]) < numbers[0]->bounds.y);
BOOST_TEST(bottom_edge(*numbers[0]) < chords[0]->bounds.y);
}
}
BOOST_AUTO_TEST_CASE(score_layout_ties_only_the_linked_chord_tone) {
auto source = boost::json::parse(score_asset_json("Partial tie"));
auto& ns = source.as_object()["staves"].as_array()[0].as_object()["measures"].as_array()[0].as_object()["voices"].as_array()[0].as_object()["notes"].as_array();
auto first = ns[0].as_object();
first["id"] = "a";
first["duration"].as_object()["numerator"] = 2;
first["written"].as_object()["type"] = "half";
auto& p = first["pitches"].as_array()[0].as_object();
p["id"] = "a-c";
p["duration"] = first["duration"];
p["written"] = first["written"];
auto other = p;
other["id"] = "a-e";
other["letter"] = "e";
first["pitches"].as_array().push_back(other);
auto second = first;
second["id"] = "b";
second["onset"].as_object()["numerator"] = 2;
second["pitches"].as_array()[0].as_object()["id"] = "b-c";
second["pitches"].as_array()[0].as_object()["tie_from"] = "a-c";
second["pitches"].as_array()[1].as_object()["id"] = "b-g";
second["pitches"].as_array()[1].as_object()["letter"] = "g";
first["pitches"].as_array()[0].as_object()["tie_to"] = "b-c";
ns = {first, second};
auto parsed = vamp_zero::parse_score_document(boost::json::serialize(source));
BOOST_REQUIRE(parsed.has_value());
auto layout = vamp_zero::layout_score_page({.x=0,.y=0,.width=976,.height=484}, *parsed, 0);
BOOST_TEST(layout_items(layout, vamp_zero::score_layout_item_role::NOTEHEAD).size() == 4U);
BOOST_TEST(layout_items(layout, vamp_zero::score_layout_item_role::TIE).size() == 1U);
ns[0].as_object()["pitches"].as_array()[1].as_object()["duration"].as_object()["numerator"] = 0;
BOOST_TEST(!vamp_zero::parse_score_document(boost::json::serialize(source)).has_value());
}
BOOST_AUTO_TEST_CASE(score_layout_clears_secondary_chord_stems_above_notation) {
auto n = note({pitch('c', "#", 5), pitch('e', "n", 5)});
n.written = {.type="quarter", .dots=2};
n.pitches[0].written = n.written;
n.pitches[1].written = {.type="eighth"};
auto score = score_with_notes({n});
score.measures[0].harmonies.push_back({"h",{0,1},"Cdim","diminished"});
auto layout = vamp_zero::layout_score_page({.x=0,.y=0,.width=976,.height=484}, score, 0);
auto chords = layout_items(layout, vamp_zero::score_layout_item_role::CHORD_SYMBOL);
BOOST_REQUIRE_EQUAL(chords.size(), 1U);
for (auto role : {vamp_zero::score_layout_item_role::STEM, vamp_zero::score_layout_item_role::FLAG})
for (auto item : layout_items(layout, role)) BOOST_TEST(bottom_edge(*chords[0]) < item->bounds.y);
}
BOOST_AUTO_TEST_CASE(accidentals_are_suppressed_when_the_key_signature_already_covers_the_pitch) {
auto c_major = vamp_zero::score_measure{
.key_signature = "C",
.notes = {
note({pitch('c', "n")}),
note({pitch('d', "n")}),
note({pitch('e', "n")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(c_major, "C"), {"none", "none", "none"});
auto f_major = vamp_zero::score_measure{
.key_signature = "F",
.notes = {
note({pitch('b', "b")}),
note({pitch('e', "n")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(f_major, "C"), {"none", "none"});
auto d_major = vamp_zero::score_measure{
.key_signature = "D",
.notes = {
note({pitch('f', "#")}),
note({pitch('c', "#")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(d_major, "C"), {"none", "none"});
}
BOOST_AUTO_TEST_CASE(accidentals_follow_measure_state_after_the_first_printed_change) {
auto measure = vamp_zero::score_measure{
.key_signature = "F",
.notes = {
note({pitch('b', "b")}),
note({pitch('b', "n")}),
note({pitch('b', "n")}),
note({pitch('b', "b")}),
note({pitch('b', "b")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(measure, "C"), {"none", "natural", "none", "flat", "none"});
}
BOOST_AUTO_TEST_CASE(measure_state_resets_for_each_measure) {
auto first = vamp_zero::score_measure{
.key_signature = "C",
.notes = {
note({pitch('f', "#")}),
note({pitch('f', "#")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(first, "C"), {"sharp", "none"});
auto second = vamp_zero::score_measure{
.key_signature = "C",
.notes = {
note({pitch('f', "#")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(second, "C"), {"sharp"});
}
BOOST_AUTO_TEST_CASE(tied_rests_hidden_and_slash_notes_do_not_emit_accidentals) {
auto measure = vamp_zero::score_measure{
.key_signature = "C",
.notes = {
note({pitch('f', "#")}, true),
rest({pitch('b', "b")}),
note({pitch('c', "#")}, false, "slash"),
note({pitch('d', "#")}, false, {}, true),
note({pitch('e', "b")}),
},
};
expect_marks(vamp_zero::notated_accidentals_for_measure(measure, "C"), {"none", "flat"});
}
BOOST_AUTO_TEST_CASE(pico_remote_display_parser_accepts_crlf_payloads) {
auto state = vamp_pico::remote_display_state{};
BOOST_REQUIRE(vamp_pico::parse_remote_display_body("active=1\r\ntitle=Autumn Leaves\r\npart=Vocal\r\nmode=score\r\npage=2\r\npages=11\r\n", state));
BOOST_TEST(state.active);
BOOST_TEST(std::strcmp(state.title, "Autumn Leaves") == 0);
BOOST_TEST(std::strcmp(state.part, "Vocal") == 0);
BOOST_TEST(std::strcmp(state.mode, "score") == 0);
BOOST_TEST(state.page == 2U);
BOOST_TEST(state.pages == 11U);
}
BOOST_AUTO_TEST_CASE(pico_remote_display_parser_rejects_bad_numbers_and_preserves_state) {
auto state = vamp_pico::remote_display_state{};
std::snprintf(state.title, sizeof(state.title), "Keep");
BOOST_TEST(!vamp_pico::parse_remote_display_body("page=1x\npages=2\n", state));
BOOST_TEST(std::strcmp(state.title, "Keep") == 0);
}
BOOST_AUTO_TEST_CASE(pico_remote_display_parser_truncates_long_fields_safely) {
auto state = vamp_pico::remote_display_state{};
auto body = std::string{"title="} + std::string(140U, 'A') + "\npart=" + std::string(80U, 'B') + "\nmode=performance-score";
BOOST_REQUIRE(vamp_pico::parse_remote_display_body(body, state));
BOOST_TEST(std::strlen(state.title) == sizeof(state.title) - 1U);
BOOST_TEST(std::strlen(state.part) == sizeof(state.part) - 1U);
BOOST_TEST(std::strcmp(state.mode, "performance-score") == 0);
}
BOOST_AUTO_TEST_CASE(database_ensure_creates_current_schema_without_version_bookkeeping) {
auto root = std::filesystem::temp_directory_path()
/ ("product-vamp-db-schema-test-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
auto database_path = root / "vamp.db";
std::filesystem::remove_all(root);
auto config = test_database_config(database_path);
BOOST_REQUIRE(run_ensure_database(config));
BOOST_REQUIRE(run_ensure_database(config));
auto tables = query_database(database_path, "SELECT name FROM sqlite_schema WHERE type = 'table' ORDER BY name");
BOOST_REQUIRE(tables);
BOOST_TEST(has_value(*tables, 0U, "songs"));
BOOST_TEST(has_value(*tables, 0U, "practice_exercises"));
BOOST_TEST(has_value(*tables, 0U, "page_state"));
BOOST_TEST(!has_value(*tables, 0U, "_noto_schema_migrations"));
auto version = query_database(database_path, "PRAGMA user_version");
BOOST_REQUIRE(version);
BOOST_REQUIRE_EQUAL(version->rows.size(), 1U);
BOOST_TEST(integer_value(version->rows[0][0]) == 0);
std::filesystem::remove_all(root);
}
BOOST_AUTO_TEST_CASE(database_ensure_updates_legacy_schema_in_place) {
auto root = std::filesystem::temp_directory_path()
/ ("product-vamp-db-legacy-test-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
auto database_path = root / "vamp.db";
std::filesystem::remove_all(root);
std::filesystem::create_directories(root);
BOOST_REQUIRE(query_database(database_path, R"sql(
CREATE TABLE songs (
id TEXT PRIMARY KEY NOT NULL CHECK(length(trim(id)) BETWEEN 1 AND 120),
title TEXT NOT NULL CHECK(length(trim(title)) BETWEEN 1 AND 200),
composer TEXT NOT NULL DEFAULT '',
source_json TEXT NOT NULL CHECK(json_valid(source_json)),
created_at_ms INTEGER NOT NULL CHECK(created_at_ms >= 0),
updated_at_ms INTEGER NOT NULL CHECK(updated_at_ms >= created_at_ms)
) STRICT
)sql"));
BOOST_REQUIRE(query_database(database_path, R"sql(
CREATE TABLE practice_exercises (
id TEXT PRIMARY KEY NOT NULL CHECK(length(trim(id)) BETWEEN 1 AND 160),
title TEXT NOT NULL CHECK(length(trim(title)) BETWEEN 1 AND 200),
composer TEXT NOT NULL DEFAULT '',
key_signature TEXT NOT NULL DEFAULT 'C',
source_json TEXT NOT NULL CHECK(json_valid(source_json)),
source_path TEXT NOT NULL DEFAULT '',
created_at_ms INTEGER NOT NULL CHECK(created_at_ms >= 0),
updated_at_ms INTEGER NOT NULL CHECK(updated_at_ms >= created_at_ms)
) STRICT
)sql"));
BOOST_REQUIRE(query_database(database_path, "CREATE TABLE _noto_schema_migrations(id TEXT PRIMARY KEY NOT NULL) STRICT"));
BOOST_REQUIRE(query_database(database_path, "PRAGMA user_version = 5"));
auto config = test_database_config(database_path);
BOOST_REQUIRE(run_ensure_database(config));
auto song_columns = query_database(database_path, "PRAGMA table_info(songs)");
BOOST_REQUIRE(song_columns);
BOOST_TEST(has_value(*song_columns, 1U, "part"));
BOOST_TEST(has_value(*song_columns, 1U, "source_path"));
BOOST_TEST(has_value(*song_columns, 1U, "key_signature"));
BOOST_TEST(has_value(*song_columns, 1U, "catalog_managed"));
auto practice_columns = query_database(database_path, "PRAGMA table_info(practice_exercises)");
BOOST_REQUIRE(practice_columns);
BOOST_TEST(has_value(*practice_columns, 1U, "practice_type_id"));
BOOST_TEST(has_value(*practice_columns, 1U, "practice_type_title"));
BOOST_TEST(has_value(*practice_columns, 1U, "lesson_group_id"));
BOOST_TEST(has_value(*practice_columns, 1U, "lesson_group_title"));
BOOST_TEST(has_value(*practice_columns, 1U, "catalog_managed"));
auto tables = query_database(database_path, "SELECT name FROM sqlite_schema WHERE type = 'table'");
BOOST_REQUIRE(tables);
BOOST_TEST(!has_value(*tables, 0U, "_noto_schema_migrations"));
auto version = query_database(database_path, "PRAGMA user_version");
BOOST_REQUIRE(version);
BOOST_REQUIRE_EQUAL(version->rows.size(), 1U);
BOOST_TEST(integer_value(version->rows[0][0]) == 0);
std::filesystem::remove_all(root);
}
BOOST_AUTO_TEST_CASE(database_import_upserts_catalog_rows_and_keeps_unmanaged_rows) {
auto root = std::filesystem::temp_directory_path()
/ ("product-vamp-db-test-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
auto assets = root / "assets";
auto database_path = root / "vamp.db";
auto song_path = assets / "songs" / "tune.json";
std::filesystem::remove_all(root);
write_text(song_path, score_asset_json("Catalog Tune"));
auto config = test_database_config(database_path);
BOOST_REQUIRE(run_ensure_database(config));
BOOST_REQUIRE(run_import(config, assets));
auto first = query_database(database_path, "SELECT title, created_at_ms, updated_at_ms, catalog_managed FROM songs WHERE id = 'tune'");
BOOST_REQUIRE(first);
BOOST_REQUIRE_EQUAL(first->rows.size(), 1U);
auto created = integer_value(first->rows[0][1]);
auto updated = integer_value(first->rows[0][2]);
BOOST_TEST(text_value(first->rows[0][0]) == "Catalog Tune");
BOOST_TEST(integer_value(first->rows[0][3]) == 1);
BOOST_REQUIRE(run_import(config, assets));
auto unchanged = query_database(database_path, "SELECT created_at_ms, updated_at_ms FROM songs WHERE id = 'tune'");
BOOST_REQUIRE(unchanged);
BOOST_REQUIRE_EQUAL(unchanged->rows.size(), 1U);
BOOST_TEST(integer_value(unchanged->rows[0][0]) == created);
BOOST_TEST(integer_value(unchanged->rows[0][1]) == updated);
std::this_thread::sleep_for(std::chrono::milliseconds{2});
write_text(song_path, score_asset_json("Catalog Tune Updated"));
BOOST_REQUIRE(run_import(config, assets));
auto changed = query_database(database_path, "SELECT title, created_at_ms, updated_at_ms FROM songs WHERE id = 'tune'");
BOOST_REQUIRE(changed);
BOOST_REQUIRE_EQUAL(changed->rows.size(), 1U);
BOOST_TEST(text_value(changed->rows[0][0]) == "Catalog Tune Updated");
BOOST_TEST(integer_value(changed->rows[0][1]) == created);
BOOST_TEST(integer_value(changed->rows[0][2]) >= updated);
auto inserted_custom = query_database(
database_path,
"INSERT INTO songs(id, title, composer, source_json, created_at_ms, updated_at_ms, part, source_path, key_signature, catalog_managed) VALUES('custom', 'Custom Tune', 'Composer', ?1, 1, 1, 'Lead', 'custom.json', 'C', 0)",
{noto::sqlite_value{score_asset_json("Custom Tune")}});
BOOST_REQUIRE(inserted_custom);
write_text(assets / "songs" / "custom.json", score_asset_json("Catalog Collision"));
BOOST_REQUIRE(run_import(config, assets));
auto custom = query_database(database_path, "SELECT title, catalog_managed FROM songs WHERE id = 'custom'");
BOOST_REQUIRE(custom);
BOOST_REQUIRE_EQUAL(custom->rows.size(), 1U);
BOOST_TEST(text_value(custom->rows[0][0]) == "Custom Tune");
BOOST_TEST(integer_value(custom->rows[0][1]) == 0);
std::filesystem::remove(assets / "songs" / "custom.json");
std::filesystem::remove(song_path);
BOOST_REQUIRE(run_import(config, assets));
auto counts = query_database(database_path, "SELECT sum(CASE WHEN id = 'tune' THEN 1 ELSE 0 END), sum(CASE WHEN id = 'custom' THEN 1 ELSE 0 END) FROM songs");
BOOST_REQUIRE(counts);
BOOST_REQUIRE_EQUAL(counts->rows.size(), 1U);
BOOST_TEST(integer_value(counts->rows[0][0]) == 0);
BOOST_TEST(integer_value(counts->rows[0][1]) == 1);
std::filesystem::remove_all(root);
}
BOOST_AUTO_TEST_CASE(score_layout_orders_preamble_on_staff_baselines) {
auto score = score_with_notes({note({pitch('e', "n")})}, "F", "4/4", "treble");
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto clefs = layout_items(layout, vamp_zero::score_layout_item_role::CLEF, 0U);
auto keys = layout_items(layout, vamp_zero::score_layout_item_role::KEY_SIGNATURE, 0U);
auto times = layout_items(layout, vamp_zero::score_layout_item_role::TIME_SIGNATURE, 0U);
auto staff_lines = layout_items(layout, vamp_zero::score_layout_item_role::STAFF_LINE, 0U);
BOOST_REQUIRE_EQUAL(clefs.size(), 1U);
BOOST_REQUIRE(!keys.empty());
BOOST_REQUIRE(!times.empty());
BOOST_REQUIRE_GE(staff_lines.size(), 5U);
BOOST_TEST(clefs.front()->bounds.x < keys.front()->bounds.x);
BOOST_TEST(keys.front()->bounds.x < times.front()->bounds.x);
BOOST_TEST(near(clefs.front()->origin.y, staff_lines.front()->from.y + layout.staff_spacing * 4.0F));
BOOST_TEST(near(keys.front()->origin.y, staff_lines.front()->from.y + layout.staff_spacing * 2.5F));
BOOST_REQUIRE_GE(times.size(), 2U);
BOOST_TEST(near(times[0]->origin.y, staff_lines.front()->from.y + layout.staff_spacing * 2.0F));
BOOST_TEST(near(times[1]->origin.y, staff_lines.front()->from.y + layout.staff_spacing * 4.0F));
}
BOOST_AUTO_TEST_CASE(score_system_ranges_force_breaks_before_key_changes) {
auto score = vamp_zero::score_document{
.title = "Key Change",
.composer = "Composer",
.key_signature = "C",
.time_signature = "4/4",
.clef = "treble",
.part = "Lead",
.measures = {
{.time_signature = "4/4", .key_signature = "C", .notes = {note({pitch('c', "n")})}},
{.time_signature = "4/4", .key_signature = "C", .notes = {note({pitch('d', "n")})}},
{.time_signature = "4/4", .key_signature = "G", .notes = {note({pitch('f', "#")})}},
{.time_signature = "4/4", .key_signature = "G", .notes = {note({pitch('g', "n")})}},
},
};
auto ranges = vamp_zero::score_system_ranges(score);
BOOST_REQUIRE_EQUAL(ranges.size(), 2U);
BOOST_TEST(ranges[0].first_measure == 0U);
BOOST_TEST(ranges[0].measure_count == 2U);
BOOST_TEST(ranges[1].first_measure == 2U);
BOOST_TEST(ranges[1].measure_count == 2U);
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
BOOST_REQUIRE(!layout_items(layout, vamp_zero::score_layout_item_role::NOTEHEAD, 1U, 2U, 0U).empty());
BOOST_TEST(!layout_items(layout, vamp_zero::score_layout_item_role::KEY_SIGNATURE, 1U).empty());
BOOST_TEST(layout_items(layout, vamp_zero::score_layout_item_role::TIME_SIGNATURE, 1U).empty());
}
BOOST_AUTO_TEST_CASE(score_system_ranges_force_breaks_before_time_changes) {
auto score = vamp_zero::score_document{
.title = "Time Change",
.composer = "Composer",
.key_signature = "C",
.time_signature = "4/4",
.clef = "treble",
.part = "Lead",
.measures = {
{.time_signature = "4/4", .key_signature = "C", .notes = {note({pitch('c', "n")})}},
{.time_signature = "4/4", .key_signature = "C", .notes = {note({pitch('d', "n")})}},
{.time_signature = "3/4", .key_signature = "C", .notes = {note({pitch('e', "n")})}},
},
};
auto ranges = vamp_zero::score_system_ranges(score);
BOOST_REQUIRE_EQUAL(ranges.size(), 2U);
BOOST_TEST(ranges[1].first_measure == 2U);
BOOST_TEST(ranges[1].measure_count == 1U);
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
BOOST_REQUIRE(!layout_items(layout, vamp_zero::score_layout_item_role::NOTEHEAD, 1U, 2U, 0U).empty());
BOOST_TEST(!layout_items(layout, vamp_zero::score_layout_item_role::TIME_SIGNATURE, 1U).empty());
}
BOOST_AUTO_TEST_CASE(score_page_count_uses_forced_notation_breaks) {
auto measures = std::vector<vamp_zero::score_measure>{};
for (auto index = std::size_t{}; index < 10U; ++index) {
measures.push_back({
.time_signature = "4/4",
.key_signature = (index / 2U) % 2U == 0U ? "C" : "G",
.notes = {note({pitch('c', "n")})},
});
}
auto score = vamp_zero::score_document{
.title = "Many Breaks",
.composer = "Composer",
.key_signature = "C",
.time_signature = "4/4",
.clef = "treble",
.part = "Lead",
.measures = std::move(measures),
};
BOOST_TEST(vamp_zero::score_page_count(score) == 3U);
}
BOOST_AUTO_TEST_CASE(score_layout_attaches_stems_to_notehead_anchors) {
auto up_score = score_with_notes({note({pitch('d', "n")})});
auto up_layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, up_score, 0U);
auto up_heads = layout_items(up_layout, vamp_zero::score_layout_item_role::NOTEHEAD, 0U, 0U, 0U);
auto up_stems = layout_items(up_layout, vamp_zero::score_layout_item_role::STEM, 0U, 0U, 0U);
BOOST_REQUIRE_EQUAL(up_heads.size(), 1U);
BOOST_REQUIRE_EQUAL(up_stems.size(), 1U);
expect_up_stem_connected(*up_heads.front(), *up_stems.front(), up_layout.staff_spacing);
auto down_score = score_with_notes({note({pitch('c', "n", 6)})});
auto down_layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, down_score, 0U);
auto down_heads = layout_items(down_layout, vamp_zero::score_layout_item_role::NOTEHEAD, 0U, 0U, 0U);
auto down_stems = layout_items(down_layout, vamp_zero::score_layout_item_role::STEM, 0U, 0U, 0U);
BOOST_REQUIRE_EQUAL(down_heads.size(), 1U);
BOOST_REQUIRE_EQUAL(down_stems.size(), 1U);
expect_down_stem_connected(*down_heads.front(), *down_stems.front(), down_layout.staff_spacing);
auto half_score = score_with_notes({note_with_ticks({pitch('d', "n")}, 8192)});
auto half_layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, half_score, 0U);
auto half_heads = layout_items(half_layout, vamp_zero::score_layout_item_role::NOTEHEAD, 0U, 0U, 0U);
auto half_stems = layout_items(half_layout, vamp_zero::score_layout_item_role::STEM, 0U, 0U, 0U);
BOOST_REQUIRE_EQUAL(half_heads.size(), 1U);
BOOST_REQUIRE_EQUAL(half_stems.size(), 1U);
expect_up_stem_connected(*half_heads.front(), *half_stems.front(), half_layout.staff_spacing);
}
BOOST_AUTO_TEST_CASE(score_layout_displaces_chord_seconds_and_columns_accidentals) {
auto score = score_with_notes({note({pitch('c', "#"), pitch('d', "#")})});
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto heads = layout_items(layout, vamp_zero::score_layout_item_role::NOTEHEAD, 0U, 0U, 0U);
auto accidentals = layout_items(layout, vamp_zero::score_layout_item_role::ACCIDENTAL, 0U, 0U, 0U);
BOOST_REQUIRE_EQUAL(heads.size(), 2U);
BOOST_REQUIRE_EQUAL(accidentals.size(), 2U);
auto const* lower_head = *std::max_element(heads.begin(), heads.end(), [](auto const* left, auto const* right) {
return center_y(*left) < center_y(*right);
});
auto const* upper_head = *std::min_element(heads.begin(), heads.end(), [](auto const* left, auto const* right) {
return center_y(*left) < center_y(*right);
});
BOOST_TEST(center_x(*upper_head) > center_x(*lower_head) + layout.staff_spacing * 0.30F);
auto const* leftmost_head = *std::min_element(heads.begin(), heads.end(), [](auto const* left, auto const* right) {
return left->bounds.x < right->bounds.x;
});
auto const* leftmost_accidental = *std::min_element(accidentals.begin(), accidentals.end(), [](auto const* left, auto const* right) {
return left->bounds.x < right->bounds.x;
});
auto const* rightmost_accidental = *std::max_element(accidentals.begin(), accidentals.end(), [](auto const* left, auto const* right) {
return left->bounds.x < right->bounds.x;
});
for (auto const* accidental : accidentals) {
BOOST_TEST(accidental->bounds.x + accidental->bounds.width < leftmost_head->bounds.x);
}
BOOST_TEST(rightmost_accidental->bounds.x - leftmost_accidental->bounds.x > layout.staff_spacing * 0.50F);
}
BOOST_AUTO_TEST_CASE(score_layout_beams_eighth_tuplets_and_labels_them) {
auto first = note_with_ticks({pitch('c', "n")}, 2048);
auto second = note_with_ticks({pitch('d', "n")}, 2048);
auto third = note_with_ticks({pitch('e', "n")}, 2048);
first.tuplet_id = "triplet-1";
second.tuplet_id = "triplet-1";
third.tuplet_id = "triplet-1";
auto score = score_with_measure({
.time_signature = "4/4",
.key_signature = "C",
.notes = {std::move(first), std::move(second), std::move(third)},
.tuplets = {{
.id = "triplet-1",
.note_count = 3,
.space_count = 2,
}},
});
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto beams = layout_items(layout, vamp_zero::score_layout_item_role::BEAM, 0U, 0U);
auto flags = layout_items(layout, vamp_zero::score_layout_item_role::FLAG, 0U, 0U);
auto tuplets = layout_items(layout, vamp_zero::score_layout_item_role::TUPLET, 0U, 0U);
BOOST_REQUIRE_EQUAL(beams.size(), 1U);
BOOST_TEST(flags.empty());
BOOST_REQUIRE_EQUAL(tuplets.size(), 1U);
BOOST_TEST(tuplets.front()->text == "3");
}
BOOST_AUTO_TEST_CASE(score_layout_keeps_dense_notation_inside_measure_guard) {
auto first = note_with_ticks({pitch('c', "#")}, 2048);
auto second = note_with_ticks({pitch('d', "#")}, 2048);
auto third = note_with_ticks({pitch('e', "n")}, 6144);
auto fourth = note_with_ticks({pitch('f', "#")}, 4096);
auto fifth = note_with_ticks({pitch('g', "#")}, 2048);
fourth.tie_to_next = true;
auto score = score_with_measure({
.time_signature = "4/4",
.key_signature = "C",
.notes = {std::move(first), std::move(second), std::move(third), std::move(fourth), std::move(fifth)},
});
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto barlines = layout_items(layout, vamp_zero::score_layout_item_role::FINAL_BARLINE, 0U, 0U);
BOOST_REQUIRE_EQUAL(barlines.size(), 1U);
auto guarded_right = barlines.front()->from.x - layout.staff_spacing;
auto roles = {
vamp_zero::score_layout_item_role::NOTEHEAD,
vamp_zero::score_layout_item_role::ACCIDENTAL,
vamp_zero::score_layout_item_role::STEM,
vamp_zero::score_layout_item_role::FLAG,
vamp_zero::score_layout_item_role::BEAM,
vamp_zero::score_layout_item_role::DOT,
vamp_zero::score_layout_item_role::TIE,
};
for (auto role : roles) {
for (auto const* item : layout_items(layout, role, 0U, 0U)) {
BOOST_TEST(right_edge(*item) <= guarded_right);
}
}
}
BOOST_AUTO_TEST_CASE(score_layout_places_lyrics_below_low_vocal_notation) {
auto low = note({pitch('c', "n", 3)});
low.lyric = "low";
auto score = score_with_notes({std::move(low)});
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto lyrics = layout_items(layout, vamp_zero::score_layout_item_role::LYRIC, 0U, 0U, 0U);
BOOST_REQUIRE_EQUAL(lyrics.size(), 1U);
auto notation_bottom = std::numeric_limits<std::float32_t>::lowest();
auto roles = {
vamp_zero::score_layout_item_role::NOTEHEAD,
vamp_zero::score_layout_item_role::ACCIDENTAL,
vamp_zero::score_layout_item_role::STEM,
vamp_zero::score_layout_item_role::FLAG,
vamp_zero::score_layout_item_role::DOT,
vamp_zero::score_layout_item_role::STAFF_LINE,
};
for (auto role : roles) {
for (auto const* item : layout_items(layout, role, 0U, 0U, 0U)) {
notation_bottom = std::max(notation_bottom, bottom_edge(*item));
}
}
BOOST_TEST(lyrics.front()->bounds.y >= notation_bottom + layout.staff_spacing * 0.70F);
}
BOOST_AUTO_TEST_CASE(score_layout_ties_to_the_actual_next_measure_notehead) {
auto tied = note_with_ticks({pitch('b', "b")}, 16384);
tied.tie_to_next = true;
auto target = note_with_ticks({pitch('b', "b")}, 4096);
target.tie_from_previous = true;
auto score = score_with_measure({
.time_signature = "4/4",
.key_signature = "F",
.notes = {std::move(tied)},
}, "F");
score.measures.push_back({
.time_signature = "4/4",
.key_signature = "F",
.notes = {std::move(target)},
});
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto ties = layout_items(layout, vamp_zero::score_layout_item_role::TIE, 0U, 0U, 0U);
auto start_heads = layout_items(layout, vamp_zero::score_layout_item_role::NOTEHEAD, 0U, 0U, 0U);
auto target_heads = layout_items(layout, vamp_zero::score_layout_item_role::NOTEHEAD, 0U, 1U, 0U);
BOOST_REQUIRE_EQUAL(ties.size(), 1U);
BOOST_REQUIRE_EQUAL(start_heads.size(), 1U);
BOOST_REQUIRE_EQUAL(target_heads.size(), 1U);
BOOST_TEST(ties.front()->from.x > right_edge(*start_heads.front()));
BOOST_TEST(ties.front()->to.x < target_heads.front()->bounds.x);
BOOST_TEST(ties.front()->to.x > right_edge(*start_heads.front()));
}
BOOST_AUTO_TEST_CASE(score_layout_draws_tie_continuations_across_system_breaks) {
auto measures = std::vector<vamp_zero::score_measure>{};
for (auto index = std::size_t{}; index < 5U; ++index) {
auto value = note_with_ticks({pitch('a', "n")}, 16384);
if (index == 3U) {
value.tie_to_next = true;
}
if (index == 4U) {
value.tie_from_previous = true;
}
measures.push_back({
.time_signature = "4/4",
.key_signature = "C",
.notes = {std::move(value)},
});
}
auto score = vamp_zero::score_document{
.title = "Break Tie",
.composer = "Composer",
.key_signature = "C",
.time_signature = "4/4",
.clef = "treble",
.part = "Lead",
.measures = std::move(measures),
};
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto outgoing = layout_items(layout, vamp_zero::score_layout_item_role::TIE, 0U, 3U, 0U);
auto incoming = layout_items(layout, vamp_zero::score_layout_item_role::TIE, 1U, 4U, 0U);
BOOST_REQUIRE_EQUAL(outgoing.size(), 1U);
BOOST_REQUIRE_EQUAL(incoming.size(), 1U);
BOOST_TEST(outgoing.front()->to.x > outgoing.front()->from.x);
BOOST_TEST(incoming.front()->to.x > incoming.front()->from.x);
}
BOOST_AUTO_TEST_CASE(score_layout_raises_chord_symbols_above_high_notation) {
auto high = note({pitch('c', "n", 6)});
high.chord_symbol = "Cmaj7";
auto score = score_with_notes({std::move(high)});
auto layout = vamp_zero::layout_score_page({.x = 0.0F, .y = 0.0F, .width = 976.0F, .height = 484.0F}, score, 0U);
auto chords = layout_items(layout, vamp_zero::score_layout_item_role::CHORD_SYMBOL, 0U, 0U);
BOOST_REQUIRE_EQUAL(chords.size(), 1U);
auto top_y = std::numeric_limits<std::float32_t>::max();
auto roles = {
vamp_zero::score_layout_item_role::NOTEHEAD,
vamp_zero::score_layout_item_role::ACCIDENTAL,
vamp_zero::score_layout_item_role::STEM,
vamp_zero::score_layout_item_role::FLAG,
vamp_zero::score_layout_item_role::BEAM,
vamp_zero::score_layout_item_role::DOT,
vamp_zero::score_layout_item_role::TUPLET,
vamp_zero::score_layout_item_role::TUPLET_BRACKET,
vamp_zero::score_layout_item_role::TIE,
};
for (auto role : roles) {
for (auto const* item : layout_items(layout, role, 0U, 0U)) {
top_y = std::min(top_y, item->bounds.y);
}
}
BOOST_TEST(right_edge(*chords.front()) <= layout.bounds.x + layout.bounds.width);
BOOST_TEST(chords.front()->bounds.y + chords.front()->bounds.height <= top_y - layout.staff_spacing * 0.40F);
}
Reference in New Issue View Git Blame Copy Permalink