233 lines
8.1 KiB
C++
233 lines
8.1 KiB
C++
//
|
|
// Created by martin on 16.11.21.
|
|
//
|
|
|
|
#include "SyncTrack.h"
|
|
#include "catch.hpp"
|
|
|
|
TEST_CASE("Basic", "[SyncTrack]") {
|
|
SyncTrack track_a;
|
|
track_a.m_num_intervals = 2;
|
|
track_a.m_duration = 2.0;
|
|
track_a.m_interval_start_ratio[0] = 0.f;
|
|
track_a.m_interval_duration_ratio[0] = 0.7;
|
|
track_a.m_interval_start_ratio[1] = 0.7f;
|
|
track_a.m_interval_duration_ratio[1] = 0.3;
|
|
|
|
SyncTrack track_b;
|
|
track_b.m_num_intervals = 2;
|
|
track_b.m_duration = 1.5;
|
|
track_b.m_interval_start_ratio[0] = 0.0f;
|
|
track_b.m_interval_duration_ratio[0] = 0.6;
|
|
track_b.m_interval_start_ratio[1] = 0.6f;
|
|
track_b.m_interval_duration_ratio[1] = 0.4;
|
|
|
|
WHEN("Calculating sync time of track_B at 0.5 duration") {
|
|
float sync_time_at_0_75 =
|
|
track_b.CalcSyncFromAbsTime(0.5 * track_b.m_duration);
|
|
REQUIRE(sync_time_at_0_75 == Catch::Detail::Approx(0.83333));
|
|
}
|
|
|
|
WHEN("Calculating sync time of track_B at 0.6 duration") {
|
|
float sync_time_at_0_6 =
|
|
track_b.CalcSyncFromAbsTime(0.6 * track_b.m_duration);
|
|
REQUIRE(sync_time_at_0_6 == Catch::Detail::Approx(1.0));
|
|
}
|
|
|
|
WHEN("Calculating sync time of track_B at 0.7 duration") {
|
|
float sync_time_at_0_7 =
|
|
track_b.CalcSyncFromAbsTime(0.7 * track_b.m_duration);
|
|
REQUIRE(sync_time_at_0_7 == Catch::Detail::Approx(1.25));
|
|
}
|
|
|
|
WHEN("Calculating sync time of track_B at 0.0 duration") {
|
|
float sync_time_at_1_0 =
|
|
track_b.CalcSyncFromAbsTime(0.0 * track_b.m_duration);
|
|
REQUIRE(sync_time_at_1_0 == Catch::Detail::Approx(0.0));
|
|
}
|
|
|
|
WHEN("Calculating sync time of track_B at 1.0 duration") {
|
|
float sync_time_at_1_0 =
|
|
track_b.CalcSyncFromAbsTime(0.9999 * track_b.m_duration);
|
|
REQUIRE(sync_time_at_1_0 == Catch::Detail::Approx(2.0).epsilon(0.001f));
|
|
}
|
|
|
|
WHEN("Calculating ratio from sync time on track_A at 0.83333") {
|
|
float ratio = track_a.CalcRatioFromSyncTime(0.83333333);
|
|
REQUIRE(ratio == Catch::Detail::Approx(0.5833333));
|
|
}
|
|
|
|
WHEN("Calculating ratio from sync time on track_A at 0.83333") {
|
|
float ratio = track_a.CalcRatioFromSyncTime(1.25);
|
|
REQUIRE(ratio == Catch::Detail::Approx(0.775));
|
|
}
|
|
|
|
WHEN("Blending two synctracks with weight 0.") {
|
|
SyncTrack blended = SyncTrack::Blend(0.f, track_a, track_b);
|
|
|
|
THEN("Result must equal track_A") { REQUIRE(track_a == blended); }
|
|
}
|
|
|
|
WHEN("Blending two synctracks with weight 1.") {
|
|
SyncTrack blended = SyncTrack::Blend(1.f, track_a, track_b);
|
|
|
|
THEN("Result must equal track_B") { REQUIRE(track_b == blended); }
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Sync Track From Marker", "[SyncTrack]") {
|
|
SyncTrack track = SyncTrack::CreateFromMarkers(2.0f, {0.9f, 0.2f});
|
|
|
|
WHEN("Querying Ratios") {
|
|
CHECK(track.m_interval_start_ratio[0] == Catch::Detail::Approx(0.45f));
|
|
CHECK(track.m_interval_duration_ratio[0] == Catch::Detail::Approx(0.65f));
|
|
|
|
CHECK(track.m_interval_start_ratio[1] == Catch::Detail::Approx(0.1f));
|
|
CHECK(track.m_interval_duration_ratio[1] == Catch::Detail::Approx(0.35f));
|
|
|
|
WHEN("Querying ratio at sync time at 0.001") {
|
|
float ratio = track.CalcRatioFromSyncTime(0.0001f);
|
|
CHECK(ratio == Catch::Detail::Approx(0.45).epsilon(0.001));
|
|
}
|
|
|
|
WHEN("Querying ratio at sync time at 0.9999") {
|
|
float ratio = track.CalcRatioFromSyncTime(0.9999f);
|
|
CHECK(ratio == Catch::Detail::Approx(0.1).epsilon(0.001));
|
|
}
|
|
|
|
WHEN("Querying ratio at sync time at 1.001") {
|
|
float ratio = track.CalcRatioFromSyncTime(1.0001f);
|
|
CHECK(ratio == Catch::Detail::Approx(0.1).epsilon(0.001));
|
|
}
|
|
|
|
WHEN("Querying ratio at sync time at 1.9999") {
|
|
float ratio = track.CalcRatioFromSyncTime(1.9999f);
|
|
CHECK(ratio == Catch::Detail::Approx(0.45).epsilon(0.001));
|
|
}
|
|
}
|
|
|
|
WHEN("Querying SyncTime from Absolute Time") {
|
|
WHEN("Querying absolute time at 0.9001s") {
|
|
float sync_time = track.CalcSyncFromAbsTime(0.9001f);
|
|
CHECK_THAT(sync_time, Catch::WithinAbs(0.0, 0.001));
|
|
}
|
|
|
|
WHEN("Querying absolute time at 0.2001s") {
|
|
float sync_time = track.CalcSyncFromAbsTime(0.2001f);
|
|
CHECK_THAT(sync_time, Catch::WithinAbs(1.0, 0.001));
|
|
}
|
|
|
|
WHEN("Querying absolute time at 0.8999s") {
|
|
float sync_time = track.CalcSyncFromAbsTime(0.8999f);
|
|
CHECK_THAT(sync_time, Catch::WithinAbs(1.999, 0.001));
|
|
}
|
|
|
|
WHEN("Querying absolute time at 1.9999s") {
|
|
float sync_time = track.CalcSyncFromAbsTime(1.9999f);
|
|
CHECK_THAT(sync_time, Catch::WithinAbs(0.84615384, 0.001));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Sync Track Blending", "[SyncTrack]") {
|
|
SyncTrack track_a = SyncTrack::CreateFromMarkers(2.0, {0., 0.6, 1.8});
|
|
SyncTrack track_b = SyncTrack::CreateFromMarkers(1.5f, {1.05, 1.35, 0.3});
|
|
|
|
WHEN("Calculating A's durations") {
|
|
CHECK(track_a.m_interval_duration_ratio[0] == Catch::Detail::Approx(0.3));
|
|
CHECK(track_a.m_interval_duration_ratio[1] == Catch::Detail::Approx(0.6));
|
|
CHECK(track_a.m_interval_duration_ratio[2] == Catch::Detail::Approx(0.1));
|
|
}
|
|
|
|
WHEN("Calculating B's durations") {
|
|
CHECK(track_b.m_interval_duration_ratio[0] == Catch::Detail::Approx(0.2));
|
|
CHECK(track_b.m_interval_duration_ratio[1] == Catch::Detail::Approx(0.3));
|
|
CHECK(track_b.m_interval_duration_ratio[2] == Catch::Detail::Approx(0.5));
|
|
}
|
|
|
|
WHEN("Blending two synctracks with weight 0.") {
|
|
SyncTrack blended = SyncTrack::Blend(0.f, track_a, track_b);
|
|
|
|
THEN("Result must equal track_A") { REQUIRE(track_a == blended); }
|
|
}
|
|
|
|
WHEN("Blending two synctracks with weight 1.") {
|
|
SyncTrack blended = SyncTrack::Blend(1.f, track_a, track_b);
|
|
|
|
THEN("Result must equal track_B") { REQUIRE(track_b == blended); }
|
|
}
|
|
|
|
WHEN("Blending with weight 0.2") {
|
|
float weight = 0.2f;
|
|
SyncTrack blended = SyncTrack::Blend(weight, track_a, track_b);
|
|
|
|
REQUIRE(
|
|
blended.m_duration
|
|
== (1.0f - weight) * track_a.m_duration + weight * track_b.m_duration);
|
|
REQUIRE(
|
|
blended.m_interval_start_ratio[0]
|
|
== fmodf(
|
|
(1.0f - weight) * (track_a.m_interval_start_ratio[0] + 1.0f)
|
|
+ weight * (track_b.m_interval_start_ratio[0]),
|
|
1.0f));
|
|
REQUIRE(
|
|
blended.m_interval_duration_ratio[1]
|
|
== (1.0f - weight) * (track_a.m_interval_duration_ratio[1])
|
|
+ weight * (track_b.m_interval_duration_ratio[1]));
|
|
REQUIRE(
|
|
blended.m_interval_duration_ratio[2]
|
|
== (1.0f - weight) * (track_a.m_interval_duration_ratio[2])
|
|
+ weight * (track_b.m_interval_duration_ratio[2]));
|
|
}
|
|
|
|
WHEN("Inverted blending with weight 0.2") {
|
|
float weight = 0.2f;
|
|
SyncTrack blended = SyncTrack::Blend(weight, track_b, track_a);
|
|
|
|
REQUIRE(
|
|
blended.m_duration
|
|
== (1.0f - weight) * track_b.m_duration + weight * track_a.m_duration);
|
|
REQUIRE(
|
|
blended.m_interval_start_ratio[0]
|
|
== fmodf(
|
|
(1.0f - weight) * (track_b.m_interval_start_ratio[0])
|
|
+ weight * (track_a.m_interval_start_ratio[0] + 1.0f),
|
|
1.0f));
|
|
REQUIRE(
|
|
blended.m_interval_duration_ratio[1]
|
|
== (1.0f - weight) * (track_b.m_interval_duration_ratio[1])
|
|
+ weight * (track_a.m_interval_duration_ratio[1]));
|
|
REQUIRE(
|
|
blended.m_interval_duration_ratio[2]
|
|
== (1.0f - weight) * (track_b.m_interval_duration_ratio[2])
|
|
+ weight * (track_a.m_interval_duration_ratio[2]));
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Serialization", "[SyncTrack]") {
|
|
SyncTrack track;
|
|
track.m_num_intervals = 3;
|
|
track.m_duration = 2.0;
|
|
track.m_interval_start_ratio[0] = 0.f;
|
|
track.m_interval_duration_ratio[0] = 0.7;
|
|
track.m_interval_start_ratio[1] = 0.7f;
|
|
track.m_interval_duration_ratio[1] = 0.3;
|
|
track.m_interval_start_ratio[2] = 0.7f;
|
|
track.m_interval_duration_ratio[2] = 0.3;
|
|
|
|
nlohmann::json synctrack_json = track;
|
|
|
|
const SyncTrack synctrack_deserialized = synctrack_json;
|
|
|
|
CHECK(synctrack_deserialized.m_duration == track.m_duration);
|
|
CHECK(synctrack_deserialized.m_num_intervals == track.m_num_intervals);
|
|
|
|
for (int i = 0; i < track.m_num_intervals; i++) {
|
|
CHECK(
|
|
synctrack_deserialized.m_interval_start_ratio[i]
|
|
== track.m_interval_start_ratio[i]);
|
|
CHECK(
|
|
synctrack_deserialized.m_interval_duration_ratio[i]
|
|
== track.m_interval_duration_ratio[i]);
|
|
}
|
|
} |