product-vamp/tests/test.cpp

#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 <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 <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/navigation.hpp>
#include <vamp_zero/parse.hpp>
#include <vamp_zero/page_control.hpp>
#include <vamp_zero/portal.hpp>
#include <vamp_zero/app.hpp>
#include <vamp_zero/score.hpp>
#include <vamp_zero/types.hpp>


namespace {

auto test_database_config(std::filesystem::path const &path) -> vamp_zero::database_config {
  return {
    .path = path.string(),
  };
}

auto score_asset_json(std::string title, std::string key = "C", std::string part = "Lead") -> std::string {
  auto value = boost::json::parse(R"json({
    "music":{"metadata":{"title":"Fixture","composer":"Composer","key_signature":"C","time_signature":"4/4"},
      "staves":[{"id":"staff-lead","name":"Lead","measures":[{"id":"measure-1","voices":[]}]}]},
    "presentation":{"title_image":"0000000000000000000000000000000000000000000000000000000000000000","width":976,"height":484,"pages":[{"path":"fixture.pages/0001.png",
      "sha256":"0000000000000000000000000000000000000000000000000000000000000000"}]}
  })json");
  auto &metadata = value.as_object()["music"].as_object()["metadata"].as_object();
  metadata["title"] = std::move(title);
  metadata["key_signature"] = std::move(key);
  value.at("music").at("staves").as_array().front().as_object()["name"] = std::move(part);
  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",
    .measure_count = 1,
    .total_pages = 2,
  };
  return vamp_zero::app_state{
    .catalog = std::make_shared<vamp_zero::catalog const>(vamp_zero::group_ordered_parts({part})),
  };
}

}

BOOST_AUTO_TEST_CASE(build_identification_uses_git_without_an_application_release_label) {
  auto program = std::string{"vamp-zero"};
  auto option = std::string{"--build-info"};
  auto args = std::vector<std::char_t *>{program.data(), option.data()};
  auto command = vamp_zero::parse_command_line(2, args.data());
  BOOST_REQUIRE(command);
  BOOST_TEST(command->print_build_info);
  command->config_path = "/nonexistent/product-vamp.json";
  BOOST_TEST(vamp_zero::run(*command).has_value());
  auto once = std::string{"--once"};
  args.push_back(once.data());
  BOOST_TEST(!vamp_zero::parse_command_line(3, args.data()));
  auto status = vamp_zero::portal_status_json({}, {}).as_object();
  BOOST_TEST(status.at("git_sha").as_string() == VAMP_GIT_SHA);
  BOOST_TEST(!status.contains("version"));
}

BOOST_AUTO_TEST_CASE(runtime_config_uses_headless_and_ignores_unknown_fields) {
  auto parsed = vamp_zero::parse_config(boost::json::parse(R"json({"runtime":{"headless":true,"obsolete_setting":"ignored"},"audio":{"enabled":false}})json"));
  BOOST_REQUIRE(parsed);
  BOOST_TEST(parsed->runtime.headless);
  BOOST_TEST(!parsed->audio.enabled);
  BOOST_TEST(parsed->database.path == "/usr/share/product-vamp/catalog.db");
  auto invalid = vamp_zero::parse_config(boost::json::parse(R"json({"runtime":{"headless":"yes"}})json"));
  BOOST_TEST(!invalid);
}

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.playback_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,
      "playback_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.playback_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);
  BOOST_TEST(state.selected_main_menu_index == 1U);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
  BOOST_TEST(state.audio.playback_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 == 2U);
  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 == 3U);
  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.playback_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("playback_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_loads_the_generated_catalog) {
  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(empty_catalog_navigation_and_main_menu_wrap) {
  auto state = vamp_zero::app_state{};
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::PREVIOUS);
  BOOST_TEST(state.selected_main_menu_index == 3U);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
  BOOST_TEST(state.selected_main_menu_index == 0U);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
  BOOST_CHECK(state.mode == vamp_zero::app_mode::PERFORMANCE_SONG_MENU);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
  BOOST_TEST(state.selected_song_index == 0U);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
  BOOST_CHECK(state.mode == vamp_zero::app_mode::MAIN_MENU);
  BOOST_REQUIRE(vamp_zero::validate_app_state(state));
  BOOST_TEST(!vamp_zero::app_status_json(state).as_object().contains("practice"));
}

BOOST_AUTO_TEST_CASE(song_part_navigation_preserves_selection_and_remote_display) {
  auto parts = std::vector<vamp_zero::library_part>{};
  for (auto name : {"Acoustic", "Electric", "Vocal"}) {
    parts.push_back({.id = name, .title = "Song", .composer = "Composer", .part = name, .total_pages = 3});
  }
  auto state = vamp_zero::app_state{
    .catalog = std::make_shared<vamp_zero::catalog const>(vamp_zero::group_ordered_parts(std::move(parts))),
  };
  state.audio.metronome_enabled = true;
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
  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);
  for (auto name : {"Acoustic", "Electric", "Vocal"}) {
    state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
    auto selection = state.selected_part_index;
    state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
    BOOST_CHECK(state.mode == vamp_zero::app_mode::PERFORMANCE_SCORE);
    BOOST_TEST(state.active_part_id == name);
    auto remote = vamp_pico::remote_display_state{};
    BOOST_REQUIRE(vamp_pico::parse_remote_display_body(vamp_zero::remote_display_text(state), remote));
    BOOST_TEST(remote.active);
    BOOST_TEST(std::string{remote.part} == name);
    BOOST_TEST(remote.pages == 3U);
    for (auto index = std::uint32_t{}; index < 4U; ++index) {
      state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
    }
    BOOST_TEST(state.page_index == 2U);
    state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
    BOOST_CHECK(state.mode == vamp_zero::app_mode::PERFORMANCE_PART_MENU);
    BOOST_TEST(state.selected_part_index == selection);
    BOOST_TEST(state.active_part_id.empty());
    BOOST_TEST(state.audio.metronome_enabled);
  }
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::NEXT);
  BOOST_TEST(state.selected_part_index == 0U);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
  BOOST_CHECK(state.mode == vamp_zero::app_mode::PERFORMANCE_SONG_MENU);
  BOOST_TEST(state.selected_song_index == 1U);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::PREVIOUS);
  state = vamp_zero::apply_app_command(std::move(state), vamp_protocol::page_command::SELECT);
  BOOST_CHECK(state.mode == vamp_zero::app_mode::MAIN_MENU);
  BOOST_REQUIRE(vamp_zero::validate_app_state(state));
}

BOOST_AUTO_TEST_CASE(database_reload_preserves_all_generated_song_parts) {
  auto config = test_database_config(std::filesystem::path{VAMP_TEST_ASSETS_DIR} / "catalog.db");
  auto expected = std::size_t{};
  for (auto const &entry : std::filesystem::directory_iterator{std::filesystem::path{VAMP_TEST_SOURCE_DIR} / "data/songs"}) {
    if (entry.is_regular_file() && entry.path().extension() == ".xml") {
      expected += 3U;
    }
  }
  BOOST_REQUIRE(expected > 0U);
  for (auto iteration = std::uint32_t{}; iteration < 2U; ++iteration) {
    auto io = boost::asio::io_context{};
    auto future = boost::asio::co_spawn(io, vamp_zero::async_load_catalog(io.get_executor(), config, VAMP_TEST_ASSETS_DIR), boost::asio::use_future);
    io.run();
    auto catalog = future.get();
    BOOST_REQUIRE_MESSAGE(catalog, (catalog ? "" : catalog.error().describe()));
    BOOST_REQUIRE_EQUAL(catalog->parts.size(), expected);
    for (auto const &part : catalog->parts) {
      io.restart();
      auto loaded = boost::asio::co_spawn(io, vamp_zero::async_load_score(io.get_executor(), config, {part.id}, VAMP_TEST_ASSETS_DIR), boost::asio::use_future);
      io.run();
      auto score = loaded.get();
      BOOST_REQUIRE_MESSAGE(score, (score ? "" : score.error().describe()));
      BOOST_TEST(score->title == part.title);
      BOOST_TEST(score->composer == part.composer);
      BOOST_TEST(score->key_signature == part.key_signature);
      BOOST_TEST(score->part == part.part);
      BOOST_TEST(score->measure_count == part.measure_count);
      BOOST_TEST(score->pages.size() == part.total_pages);
      BOOST_TEST(score->source_path == part.source_path);
    }
  }
}

BOOST_AUTO_TEST_CASE(keyless_scores_keep_their_authored_key) {
  auto source = score_asset_json("Keyless", "No key", "Vocal");
  auto document = vamp_zero::parse_score_document(source, "vocal.json");
  BOOST_REQUIRE(document);
  BOOST_TEST(document->key_signature == "No key");
  BOOST_TEST(document->part == "Vocal");
}

BOOST_AUTO_TEST_CASE(integer_parsing_checks_range_sign_and_entire_input) {
  BOOST_TEST(vamp_zero::parse_integer<std::uint16_t>("65535", "port").value_or(0) == 65535U);
  BOOST_TEST(vamp_zero::parse_integer<std::int32_t>("-2147483648", "octave").value_or(0) == std::numeric_limits<std::int32_t>::min());
  BOOST_TEST(vamp_zero::parse_integer<std::uint64_t>("18446744073709551615", "page").value_or(0) == std::numeric_limits<std::uint64_t>::max());
  for (auto text : {"", "-1", "+1", " 1", "1 ", "123x", "1.5", "65536", "18446744073709551616"}) {
    auto parsed = vamp_zero::parse_integer<std::uint16_t>(text, "port");
    BOOST_REQUIRE(!parsed.has_value());
    BOOST_TEST(parsed.error().code() == static_cast<std::int32_t>(vamp_zero::error_code::INVALID_ARGUMENT));
    BOOST_TEST(parsed.error().message().starts_with("port "));
  }
}

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(score_bundle_preserves_complete_music_without_runtime_flattening) {
  auto source = score_asset_json("Fixture");
  auto parsed = vamp_zero::parse_score_document(source, "fixture.json");
  BOOST_REQUIRE(parsed);
  BOOST_TEST(parsed->title == "Fixture");
  BOOST_TEST(parsed->measure_count == 1U);
  BOOST_TEST(parsed->source_json == source);
  BOOST_TEST(vamp_zero::score_page_count(*parsed) == 1U);
}

BOOST_AUTO_TEST_CASE(score_bundle_rejects_malformed_structure_manifest_and_unsafe_paths) {
  for (auto text : {"", "null", "[]", "{}", "{", R"({"music":{}})", R"({"presentation":{}})"}) {
    BOOST_CHECK_NO_THROW(BOOST_TEST(!vamp_zero::parse_score_document(text)));
  }
  for (auto path : {"../page.png", "/page.png", "pages/../../page.png", "pages/./page.png", "page.jpg", ""}) {
    auto value = boost::json::parse(score_asset_json("Fixture"));
    value.at_pointer("/presentation/pages/0").as_object()["path"] = path;
    BOOST_TEST(!vamp_zero::parse_score_document(boost::json::serialize(value)));
  }
  for (auto pointer : {"/music", "/music/metadata", "/music/staves", "/presentation", "/presentation/pages",
                       "/presentation/width", "/presentation/pages/0/path", "/presentation/pages/0/sha256"}) {
    auto value = boost::json::parse(score_asset_json("Fixture"));
    value.at_pointer(pointer) = nullptr;
    BOOST_CHECK_NO_THROW(BOOST_TEST(!vamp_zero::parse_score_document(boost::json::serialize(value))));
  }
}

BOOST_AUTO_TEST_CASE(score_page_validation_reports_missing_assets) {
  auto parsed = vamp_zero::parse_score_document(score_asset_json("Fixture"), "/nonexistent/fixture.json");
  BOOST_REQUIRE(parsed);
  BOOST_TEST(!vamp_zero::validated_page_path(*parsed, 0));
  BOOST_TEST(!vamp_zero::validated_page_path(*parsed, 1));
}

BOOST_AUTO_TEST_CASE(score_page_validation_checks_integrity_and_symlink_boundaries) {
  auto root = std::filesystem::temp_directory_path() / ("vamp-page-test-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
  auto assets = root / "assets";
  std::filesystem::create_directories(assets);
  auto page = assets / "page.png";
  std::filesystem::copy_file(std::filesystem::path{VAMP_TEST_SOURCE_DIR} / "tests/fixtures/engraving.png", page);
  auto parsed = vamp_zero::parse_score_document(score_asset_json("Fixture"), (assets / "score.json").string());
  BOOST_REQUIRE(parsed);
  parsed->pages[0] = {.path = "page.png", .sha256 = "3bb4d7bd173db4517afed83f512b636f56f053a60e2b08db09106e0698f40284"};
  BOOST_REQUIRE(vamp_zero::validated_page_path(*parsed, 0));
  {
    auto output = std::ofstream{page, std::ios::binary | std::ios::app};
    output << "corrupt";
  }
  BOOST_TEST(!vamp_zero::validated_page_path(*parsed, 0));
  std::filesystem::rename(page, root / "outside.png");
  std::filesystem::create_symlink(root / "outside.png", page);
  BOOST_TEST(!vamp_zero::validated_page_path(*parsed, 0));
  std::filesystem::remove_all(root);
}

BOOST_AUTO_TEST_CASE(score_page_cache_retains_at_most_two_textures) {
  class page_texture final : public luma::texture {
  public:
    auto info() const -> luma::texture_info override {
      return {.width = 976, .height = 484};
    }
  };

  auto calls = std::size_t{};
  auto weak = std::vector<std::weak_ptr<luma::texture>>{};
  auto cache = vamp_zero::score_page_cache{[&](std::string const &) -> std::expected<std::shared_ptr<luma::texture>, modulus::error> {
    ++calls;
    auto texture = std::make_shared<page_texture>();
    weak.push_back(texture);
    return texture;
  }};
  BOOST_REQUIRE(cache.get("one"));
  BOOST_REQUIRE(cache.get("two"));
  BOOST_REQUIRE(cache.get("one"));
  BOOST_TEST(calls == 2U);
  BOOST_REQUIRE(cache.get("three"));
  BOOST_TEST(cache.size() == 2U);
  BOOST_TEST(weak[1].expired());
  BOOST_TEST(!weak[0].expired());
  cache.clear();
  BOOST_TEST(weak[0].expired());
  BOOST_TEST(weak[2].expired());
}