30501467811

Committed 30 Jul 2026 12:03AM UTC coverage: 48.37% (+0.7%) from 47.696%

Build # 30501467811

Build Type

push

github

Committed by

jcelerier

Commit Message

tests: fix the time_signature narrowing in the quantification helper

time_signature holds uint16_t; passing int members through a braced
initializer is a narrowing conversion and clang rejects it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Coverage Stats

26683 of 55164 relevant lines covered (48.37%)

188617.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.26

/tests/Dataflow/TokenRequestTest.cpp

#include "../Editor/TestUtils.hpp"

#include <ossia/detail/config.hpp>

#include <ossia/dataflow/token_request.hpp>

#include "include_catch.hpp"

#include <iterator>
#include <utility>
#include <vector>
TEST_CASE("test_loops_integer", "test_loops_integer")
{
  using namespace ossia;

  token_request r;
  r.prev_date = 0_tv;
  r.date = 100_tv;

  token_request_vec vec;
  r.loop(
      0_tv, 10_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});

  simple_token_request_vec expected{
      {.prev_date = 0_tv, .date = 10_tv, .offset = 0_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 10_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 20_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 30_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 40_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 50_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 60_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 70_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 80_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 90_tv}};

  REQUIRE(expected == vec);
}

TEST_CASE("test_loops_fract", "test_loops_fract")
{
  using namespace ossia;

  token_request r;
  r.prev_date = 0_tv;
  r.date = 97_tv;

  token_request_vec vec;
  r.loop(
      0_tv, 10_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});

  simple_token_request_vec expected{
      {.prev_date = 0_tv, .date = 10_tv, .offset = 0_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 10_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 20_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 30_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 40_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 50_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 60_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 70_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 80_tv},
      {.prev_date = 0_tv, .date = 7_tv, .offset = 90_tv}};

  REQUIRE(expected == vec);
}

TEST_CASE("test_loops_offset", "test_loops_offset")
{
  using namespace ossia;

  token_request r;
  r.prev_date = 2_tv;
  r.date = 12_tv;

  token_request_vec vec;
  r.loop(
      0_tv, 5_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});

  simple_token_request_vec expected{
      {.prev_date = 2_tv, .date = 5_tv, .offset = 0_tv},
      {.prev_date = 0_tv, .date = 5_tv, .offset = 3_tv},
      {.prev_date = 0_tv, .date = 2_tv, .offset = 8_tv},
  };

  REQUIRE(expected == vec);
}

TEST_CASE("test_loops_smaller", "test_loops_smaller")
{
  using namespace ossia;

  token_request r;
  r.prev_date = 0_tv;
  r.date = 15_tv;

  token_request_vec vec;
  r.loop(
      0_tv, 20_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});

  simple_token_request_vec expected{{.prev_date = 0_tv, .date = 15_tv, .offset = 0_tv}};

  REQUIRE(expected == vec);
}

TEST_CASE("test_loops_mid", "test_loops_mid")
{
  using namespace ossia;

  token_request r;
  r.prev_date = 15_tv;
  r.date = 30_tv;

  token_request_vec vec;
  r.loop(
      0_tv, 20_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});

  simple_token_request_vec expected{
      {.prev_date = 15_tv, .date = 20_tv, .offset = 0_tv},
      {.prev_date = 0_tv, .date = 10_tv, .offset = 5_tv}};

  REQUIRE(expected == vec);
}

TEST_CASE("test_musical_quantization", "test_musical_quantization")
{
  using namespace ossia;

  token_request r;
  r.prev_date = 0_tv;
  r.date = 2048000_tv;
  r.musical_end_last_bar = 0.005804985827664399;
  r.musical_end_position = 0.005804985827664399;

  auto res = r.get_quantification_date(8.0);
  REQUIRE(res == 0_tv);
}

namespace
{
using date_list = std::vector<std::pair<int64_t, int64_t>>;

//! A tick covering [prev; date[ in model time and [mstart; mend[ in quarters.
ossia::token_request musical_tick(
    int64_t prev, int64_t date, double mstart, double mend, uint16_t num = 4, uint16_t denom = 4)
{
  ossia::token_request t;
  t.prev_date = ossia::time_value{prev};
  t.date = ossia::time_value{date};
  t.musical_start_position = mstart;
  t.musical_end_position = mend;
  t.musical_start_last_bar = 0.;
  t.musical_start_last_signature = 0.;
  t.signature = ossia::time_signature{num, denom};
  return t;
}

date_list dates(const ossia::quantification_points& p)
{
  date_list out;
  for(auto& q : p)
    out.emplace_back(q.date.impl, q.index);
  return out;
}
}

TEST_CASE("quantification_dates_empty_tick", "quantification_dates")
{
  auto t = musical_tick(100, 100, 0., 1.);
  REQUIRE(t.get_quantification_dates(4).empty());
}

TEST_CASE("quantification_dates_no_rate", "quantification_dates")
{
  // A null or negative rate means "as soon as possible".
  auto t = musical_tick(100, 200, 0., 1.);
  REQUIRE(dates(t.get_quantification_dates(0)) == date_list{{100, 0}});
  REQUIRE(dates(t.get_quantification_dates(-1)) == date_list{{100, 0}});
}

TEST_CASE("quantification_dates_no_musical_info", "quantification_dates")
{
  // Without a musical position there is nothing to quantize against: the tick
  // itself is the point. Several nodes rely on this to step once per tick.
  auto t = musical_tick(100, 200, 0., 0.);
  REQUIRE(dates(t.get_quantification_dates(16)) == date_list{{100, 0}});
}

TEST_CASE("quantification_dates_several_per_tick", "quantification_dates")
{
  // The whole point of the multi-date version: one tick worth a quarter note
  // holds four sixteenths, and none of them may be dropped.
  auto t = musical_tick(0, 1000, 0., 1.);

  const auto expected = date_list{{0, 0}, {250, 1}, {500, 2}, {750, 3}};
  REQUIRE(dates(t.get_quantification_dates(16)) == expected);
}

TEST_CASE("quantification_dates_interior_point", "quantification_dates")
{
  auto t = musical_tick(0, 1000, 0.5, 1.5);
  const auto res = t.get_quantification_dates(4);

  REQUIRE(dates(res) == date_list{{500, 1}});
  // and it agrees with the single-date version
  auto single = t.get_quantification_date(4);
  REQUIRE(single.has_value());
  REQUIRE(*single == res[0].date);
}

TEST_CASE("quantification_dates_on_the_start_of_the_tick", "quantification_dates")
{
  auto t = musical_tick(400, 1000, 1., 1.5);
  const auto res = t.get_quantification_dates(4);

  REQUIRE(dates(res) == date_list{{400, 1}});

  auto single = t.get_quantification_date(4);
  REQUIRE(single.has_value());
  REQUIRE(*single == res[0].date);
}

TEST_CASE("quantification_dates_on_the_end_of_the_tick", "quantification_dates")
{
  // A point falling exactly on the end of a tick belongs to the next one,
  // otherwise it would fire twice.
  auto t = musical_tick(0, 1000, 0.5, 1.);
  REQUIRE(t.get_quantification_dates(4).empty());
  REQUIRE(!t.get_quantification_date(4).has_value());
}

TEST_CASE("quantification_dates_bars", "quantification_dates")
{
  // rate <= 1 counts bars: 1 is every bar, 0.5 every two bars.
  auto t = musical_tick(0, 1000, 0., 8.);

  REQUIRE(dates(t.get_quantification_dates(1)) == date_list{{0, 0}, {500, 1}});
  REQUIRE(dates(t.get_quantification_dates(0.5)) == date_list{{0, 0}});
}

TEST_CASE("quantification_dates_odd_signature", "quantification_dates")
{
  // 7/8: a bar is 3.5 quarters.
  auto t = musical_tick(0, 1000, 0., 7., 7, 8);
  REQUIRE(dates(t.get_quantification_dates(1)) == date_list{{0, 0}, {500, 1}});
}

TEST_CASE("quantification_dates_are_ordered_and_inside_the_tick", "quantification_dates")
{
  for(double rate : {1., 2., 4., 8., 16., 32.})
  {
    auto t = musical_tick(0, 4096, 0.3, 5.7);
    const auto res = t.get_quantification_dates(rate);

    INFO("rate " << rate);
    int64_t previous = -1;
    for(const auto& q : res)
    {
      CHECK(q.date.impl >= t.prev_date.impl);
      CHECK(q.date.impl < t.date.impl);
      CHECK(q.date.impl >= previous);
      previous = q.date.impl;
    }
  }
}

1	#include "../Editor/TestUtils.hpp"
2
3	#include <ossia/detail/config.hpp>
4
5	#include <ossia/dataflow/token_request.hpp>
6
7	#include "include_catch.hpp"
8
9	#include <iterator>
10	#include <utility>
11	#include <vector>
12	TEST_CASE("test_loops_integer", "test_loops_integer")	1✔
13	{
14	using namespace ossia;
15
16	token_request r;	1✔
17	r.prev_date = 0_tv;	1✔
18	r.date = 100_tv;	1✔
19
20	token_request_vec vec;	1✔
21	r.loop(	1✔
22	0_tv, 10_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});	20✔
23
24	simple_token_request_vec expected{
25	{.prev_date = 0_tv, .date = 10_tv, .offset = 0_tv},
26	{.prev_date = 0_tv, .date = 10_tv, .offset = 10_tv},
27	{.prev_date = 0_tv, .date = 10_tv, .offset = 20_tv},
28	{.prev_date = 0_tv, .date = 10_tv, .offset = 30_tv},
29	{.prev_date = 0_tv, .date = 10_tv, .offset = 40_tv},
30	{.prev_date = 0_tv, .date = 10_tv, .offset = 50_tv},
31	{.prev_date = 0_tv, .date = 10_tv, .offset = 60_tv},
32	{.prev_date = 0_tv, .date = 10_tv, .offset = 70_tv},
33	{.prev_date = 0_tv, .date = 10_tv, .offset = 80_tv},
34	{.prev_date = 0_tv, .date = 10_tv, .offset = 90_tv}};	1✔
35
36	REQUIRE(expected == vec);	1✔
37	}	1✔
38
39	TEST_CASE("test_loops_fract", "test_loops_fract")	1✔
40	{
41	using namespace ossia;
42
43	token_request r;	1✔
44	r.prev_date = 0_tv;	1✔
45	r.date = 97_tv;	1✔
46
47	token_request_vec vec;	1✔
48	r.loop(	1✔
49	0_tv, 10_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});	19✔
50
51	simple_token_request_vec expected{
52	{.prev_date = 0_tv, .date = 10_tv, .offset = 0_tv},
53	{.prev_date = 0_tv, .date = 10_tv, .offset = 10_tv},
54	{.prev_date = 0_tv, .date = 10_tv, .offset = 20_tv},
55	{.prev_date = 0_tv, .date = 10_tv, .offset = 30_tv},
56	{.prev_date = 0_tv, .date = 10_tv, .offset = 40_tv},
57	{.prev_date = 0_tv, .date = 10_tv, .offset = 50_tv},
58	{.prev_date = 0_tv, .date = 10_tv, .offset = 60_tv},
59	{.prev_date = 0_tv, .date = 10_tv, .offset = 70_tv},
60	{.prev_date = 0_tv, .date = 10_tv, .offset = 80_tv},
61	{.prev_date = 0_tv, .date = 7_tv, .offset = 90_tv}};	1✔
62
63	REQUIRE(expected == vec);	1✔
64	}	1✔
65
66	TEST_CASE("test_loops_offset", "test_loops_offset")	1✔
67	{
68	using namespace ossia;
69
70	token_request r;	1✔
71	r.prev_date = 2_tv;	1✔
72	r.date = 12_tv;	1✔
73
74	token_request_vec vec;	1✔
75	r.loop(	1✔
76	0_tv, 5_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});	5✔
77
78	simple_token_request_vec expected{
79	{.prev_date = 2_tv, .date = 5_tv, .offset = 0_tv},
80	{.prev_date = 0_tv, .date = 5_tv, .offset = 3_tv},
81	{.prev_date = 0_tv, .date = 2_tv, .offset = 8_tv},
82	};	1✔
83
84	REQUIRE(expected == vec);	1✔
85	}	1✔
86
87	TEST_CASE("test_loops_smaller", "test_loops_smaller")	1✔
88	{
89	using namespace ossia;
90
91	token_request r;	1✔
92	r.prev_date = 0_tv;	1✔
93	r.date = 15_tv;	1✔
94
95	token_request_vec vec;	1✔
96	r.loop(	1✔
97	0_tv, 20_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});	1✔
98
99	simple_token_request_vec expected{{.prev_date = 0_tv, .date = 15_tv, .offset = 0_tv}};	1✔
100
101	REQUIRE(expected == vec);	1✔
102	}	1✔
103
104	TEST_CASE("test_loops_mid", "test_loops_mid")	1✔
105	{
106	using namespace ossia;
107
108	token_request r;	1✔
109	r.prev_date = 15_tv;	1✔
110	r.date = 30_tv;	1✔
111
112	token_request_vec vec;	1✔
113	r.loop(	1✔
114	0_tv, 20_tv, [&](auto& req) { vec.push_back(req); }, [](const auto&) {});	3✔
115
116	simple_token_request_vec expected{
117	{.prev_date = 15_tv, .date = 20_tv, .offset = 0_tv},
118	{.prev_date = 0_tv, .date = 10_tv, .offset = 5_tv}};	1✔
119
120	REQUIRE(expected == vec);	1✔
121	}	1✔
122
123	TEST_CASE("test_musical_quantization", "test_musical_quantization")	1✔
124	{
125	using namespace ossia;
126
127	token_request r;	1✔
128	r.prev_date = 0_tv;	1✔
129	r.date = 2048000_tv;	1✔
130	r.musical_end_last_bar = 0.005804985827664399;	1✔
131	r.musical_end_position = 0.005804985827664399;	1✔
132
133	auto res = r.get_quantification_date(8.0);	1✔
134	REQUIRE(res == 0_tv);	1✔
135	}	1✔
136
137	namespace
138	{
139	using date_list = std::vector<std::pair<int64_t, int64_t>>;
140
141	//! A tick covering [prev; date[ in model time and [mstart; mend[ in quarters.
142	ossia::token_request musical_tick(	15✔
143	int64_t prev, int64_t date, double mstart, double mend, uint16_t num = 4, uint16_t denom = 4)
144	{
145	ossia::token_request t;	15✔
146	t.prev_date = ossia::time_value{prev};	15✔
147	t.date = ossia::time_value{date};	15✔
148	t.musical_start_position = mstart;	15✔
149	t.musical_end_position = mend;	15✔
150	t.musical_start_last_bar = 0.;	15✔
151	t.musical_start_last_signature = 0.;	15✔
152	t.signature = ossia::time_signature{num, denom};	15✔
153	return t;	15✔
154	}
155
156	date_list dates(const ossia::quantification_points& p)	9✔
157	{
158	date_list out;	9✔
159	for(auto& q : p)	23✔
160	out.emplace_back(q.date.impl, q.index);	14✔
161	return out;	9✔
162	}	×
163	}
164
165	TEST_CASE("quantification_dates_empty_tick", "quantification_dates")	1✔
166	{
167	auto t = musical_tick(100, 100, 0., 1.);	1✔
168	REQUIRE(t.get_quantification_dates(4).empty());	1✔
169	}	1✔
170
171	TEST_CASE("quantification_dates_no_rate", "quantification_dates")	1✔
172	{
173	// A null or negative rate means "as soon as possible".
174	auto t = musical_tick(100, 200, 0., 1.);	1✔
175	REQUIRE(dates(t.get_quantification_dates(0)) == date_list{{100, 0}});	3✔
176	REQUIRE(dates(t.get_quantification_dates(-1)) == date_list{{100, 0}});	3✔
177	}	1✔
178
179	TEST_CASE("quantification_dates_no_musical_info", "quantification_dates")	1✔
180	{
181	// Without a musical position there is nothing to quantize against: the tick
182	// itself is the point. Several nodes rely on this to step once per tick.
183	auto t = musical_tick(100, 200, 0., 0.);	1✔
184	REQUIRE(dates(t.get_quantification_dates(16)) == date_list{{100, 0}});	3✔
185	}	1✔
186
187	TEST_CASE("quantification_dates_several_per_tick", "quantification_dates")	1✔
188	{
189	// The whole point of the multi-date version: one tick worth a quarter note
190	// holds four sixteenths, and none of them may be dropped.
191	auto t = musical_tick(0, 1000, 0., 1.);	1✔
192
193	const auto expected = date_list{{0, 0}, {250, 1}, {500, 2}, {750, 3}};	2✔
194	REQUIRE(dates(t.get_quantification_dates(16)) == expected);	1✔
195	}	1✔
196
197	TEST_CASE("quantification_dates_interior_point", "quantification_dates")	1✔
198	{
199	auto t = musical_tick(0, 1000, 0.5, 1.5);	1✔
200	const auto res = t.get_quantification_dates(4);	1✔
201
202	REQUIRE(dates(res) == date_list{{500, 1}});	3✔
203	// and it agrees with the single-date version
204	auto single = t.get_quantification_date(4);	1✔
205	REQUIRE(single.has_value());	1✔
206	REQUIRE(*single == res[0].date);	1✔
207	}	1✔
208
209	TEST_CASE("quantification_dates_on_the_start_of_the_tick", "quantification_dates")	1✔
210	{
211	auto t = musical_tick(400, 1000, 1., 1.5);	1✔
212	const auto res = t.get_quantification_dates(4);	1✔
213
214	REQUIRE(dates(res) == date_list{{400, 1}});	3✔
215
216	auto single = t.get_quantification_date(4);	1✔
217	REQUIRE(single.has_value());	1✔
218	REQUIRE(*single == res[0].date);	1✔
219	}	1✔
220
221	TEST_CASE("quantification_dates_on_the_end_of_the_tick", "quantification_dates")	1✔
222	{
223	// A point falling exactly on the end of a tick belongs to the next one,
224	// otherwise it would fire twice.
225	auto t = musical_tick(0, 1000, 0.5, 1.);	1✔
226	REQUIRE(t.get_quantification_dates(4).empty());	1✔
227	REQUIRE(!t.get_quantification_date(4).has_value());	1✔
228	}	1✔
229
230	TEST_CASE("quantification_dates_bars", "quantification_dates")	1✔
231	{
232	// rate <= 1 counts bars: 1 is every bar, 0.5 every two bars.
233	auto t = musical_tick(0, 1000, 0., 8.);	1✔
234
235	REQUIRE(dates(t.get_quantification_dates(1)) == date_list{{0, 0}, {500, 1}});	3✔
236	REQUIRE(dates(t.get_quantification_dates(0.5)) == date_list{{0, 0}});	3✔
237	}	1✔
238
239	TEST_CASE("quantification_dates_odd_signature", "quantification_dates")	1✔
240	{
241	// 7/8: a bar is 3.5 quarters.
242	auto t = musical_tick(0, 1000, 0., 7., 7, 8);	1✔
243	REQUIRE(dates(t.get_quantification_dates(1)) == date_list{{0, 0}, {500, 1}});	3✔
244	}	1✔
245
246	TEST_CASE("quantification_dates_are_ordered_and_inside_the_tick", "quantification_dates")	1✔
247	{
248	for(double rate : {1., 2., 4., 8., 16., 32.})	7✔
249	{
250	auto t = musical_tick(0, 4096, 0.3, 5.7);	6✔
251	const auto res = t.get_quantification_dates(rate);	6✔
252
253	INFO("rate " << rate);	6✔
254	int64_t previous = -1;	6✔
255	for(const auto& q : res)	89✔
256	{
257	CHECK(q.date.impl >= t.prev_date.impl);	83✔
258	CHECK(q.date.impl < t.date.impl);	83✔
259	CHECK(q.date.impl >= previous);	83✔
260	previous = q.date.impl;	83✔
261	}
262	}	6✔
263	}	1✔

ossia / libossia / 30501467811

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous