libs/evoral/test/BeatsTest.cc

   1 #include <stdlib.h>
   2
   3 #include "BeatsTest.h"
   4 #include "temporal/beats.h"
   5
   6 CPPUNIT_TEST_SUITE_REGISTRATION(BeatsTest);
   7
   8 using namespace Evoral;
   9 using namespace Temporal;
  10
  11 static const double delta = 1.5 / (double)Beats::PPQN;
  12
  13 void
  14 BeatsTest::createTest()
  15 {
  16         const Beats a(1, 2);
  17         CPPUNIT_ASSERT_EQUAL(1, a.get_beats());
  18         CPPUNIT_ASSERT_EQUAL(2, a.get_ticks());
  19         CPPUNIT_ASSERT_DOUBLES_EQUAL(1 + 2 / (double)Beats::PPQN, a.to_double(), delta);
  20
  21         const Beats b(1.5);
  22         CPPUNIT_ASSERT_EQUAL(1, b.get_beats());
  23         CPPUNIT_ASSERT_EQUAL(Beats::PPQN / 2, b.get_ticks());
  24         CPPUNIT_ASSERT_DOUBLES_EQUAL(1.5, b.to_double(), delta);
  25
  26         const Beats c = Beats::beats(6);
  27         CPPUNIT_ASSERT_EQUAL(6, c.get_beats());
  28         CPPUNIT_ASSERT_EQUAL(0, c.get_ticks());
  29
  30         const Beats d = Beats::ticks(7);
  31         CPPUNIT_ASSERT_EQUAL(0, d.get_beats());
  32         CPPUNIT_ASSERT_EQUAL(7, d.get_ticks());
  33
  34         Beats e(8, 9);
  35         e = d;
  36         CPPUNIT_ASSERT_EQUAL(d, e);
  37
  38
  39         // const Beats diff = n2 - n1;
  40         // CPPUNIT_ASSERT_EQUAL(-44, diff.get_beats());
  41         // CPPUNIT_ASSERT_EQUAL(44 / Beats::PPQN, diff.get_ticks());
  42         // CPPUNIT_ASSERT_DOUBLES_EQUAL(diff.to_double(), -44.44, delta);
  43 }
  44
  45 void
  46 BeatsTest::addTest()
  47 {
  48         const Beats a(1, 2);
  49         const Beats b(3, 4);
  50
  51         // Positive + positive
  52         const Beats c = a + b;
  53         CPPUNIT_ASSERT_EQUAL(4, c.get_beats());
  54         CPPUNIT_ASSERT_EQUAL(6, c.get_ticks());
  55
  56         const Beats n1(-12.34);
  57         CPPUNIT_ASSERT_DOUBLES_EQUAL(-12.34, n1.to_double(), delta);
  58
  59         const Beats n2(-56.78);
  60         CPPUNIT_ASSERT_DOUBLES_EQUAL(-56.78, n2.to_double(), delta);
  61
  62         // Positive + negative
  63         const Beats p1(1.0);
  64         const Beats p_n = p1 + n1;
  65         CPPUNIT_ASSERT_EQUAL(-11, p_n.get_beats());
  66         CPPUNIT_ASSERT_EQUAL((int32_t)(Beats::PPQN * -0.34), p_n.get_ticks());
  67         CPPUNIT_ASSERT_DOUBLES_EQUAL(-11.34, p_n.to_double(), delta);
  68
  69         // Negative + positive
  70         const Beats n_p = n1 + p1;
  71         CPPUNIT_ASSERT_EQUAL(-11, n_p.get_beats());
  72         CPPUNIT_ASSERT_EQUAL((int32_t)(Beats::PPQN * -0.34), n_p.get_ticks());
  73         CPPUNIT_ASSERT_DOUBLES_EQUAL(-11.34, n_p.to_double(), delta);
  74
  75         // Negative + negative
  76         const Beats sum = n1 + n2;
  77         CPPUNIT_ASSERT_EQUAL(-69, sum.get_beats());
  78         //CPPUNIT_ASSERT_EQUAL((int32_t)(Beats::PPQN * -0.12), n_p.get_ticks());
  79         CPPUNIT_ASSERT_DOUBLES_EQUAL(-69.12, sum.to_double(), delta);
  80 }
  81
  82 void
  83 BeatsTest::subtractTest()
  84 {
  85         const Beats a(1, 2);
  86         const Beats b(3, 4);
  87
  88         // Positive - positive
  89         const Beats c = b - a;
  90         CPPUNIT_ASSERT_EQUAL(2, c.get_beats());
  91         CPPUNIT_ASSERT_EQUAL(2, c.get_ticks());
  92
  93         const Beats n1(-12.34);
  94         CPPUNIT_ASSERT_DOUBLES_EQUAL(-12.34, n1.to_double(), delta);
  95
  96         const Beats n2(-56.78);
  97         CPPUNIT_ASSERT_DOUBLES_EQUAL(-56.78, n2.to_double(), delta);
  98
  99         // Positive - negative
 100         const Beats p1(1.0);
 101         const Beats p_n = p1 - n1;
 102         CPPUNIT_ASSERT_EQUAL(13, p_n.get_beats());
 103         CPPUNIT_ASSERT_EQUAL((int32_t)(Beats::PPQN * 0.34), p_n.get_ticks());
 104         CPPUNIT_ASSERT_DOUBLES_EQUAL(13.34, p_n.to_double(), delta);
 105
 106         // Negative - positive
 107         const Beats n_p = n1 - p1;
 108         CPPUNIT_ASSERT_EQUAL(-13, n_p.get_beats());
 109         CPPUNIT_ASSERT_EQUAL((int32_t)(Beats::PPQN * -0.34), n_p.get_ticks());
 110         CPPUNIT_ASSERT_DOUBLES_EQUAL(-13.34, n_p.to_double(), delta);
 111
 112         // Negative - negative
 113         const Beats diff = n1 - n2;
 114         CPPUNIT_ASSERT_EQUAL(44, diff.get_beats());
 115         CPPUNIT_ASSERT_EQUAL((int32_t)lrint(Beats::PPQN * 0.44), diff.get_ticks());
 116         CPPUNIT_ASSERT_DOUBLES_EQUAL(44.44, diff.to_double(), delta);
 117 }
 118
 119 void
 120 BeatsTest::multiplyTest()
 121 {
 122         CPPUNIT_ASSERT_DOUBLES_EQUAL(3.0, (Beats(1.5) * 2.0).to_double(), delta);
 123         CPPUNIT_ASSERT_DOUBLES_EQUAL(-10.0, (Beats(5.0) * -2.0).to_double(), delta);
 124         CPPUNIT_ASSERT_DOUBLES_EQUAL(-10.0, (Beats(-5.0) * 2.0).to_double(), delta);
 125 }
 126
 127 void
 128 BeatsTest::roundTest()
 129 {
 130         Beats a(1, 1);
 131
 132         // Round a up
 133         const Beats au = a.round_up_to_beat();
 134         CPPUNIT_ASSERT_EQUAL(au.get_beats(), 2);
 135         CPPUNIT_ASSERT_EQUAL(au.get_ticks(), 0);
 136
 137         // Round a down
 138         const Beats ad = a.round_down_to_beat();
 139         CPPUNIT_ASSERT_EQUAL(ad.get_beats(), 1);
 140         CPPUNIT_ASSERT_EQUAL(ad.get_ticks(), 0);
 141
 142         // Round result down again
 143         const Beats add = ad.round_down_to_beat();
 144         CPPUNIT_ASSERT_EQUAL(ad, add);
 145
 146         // Round result up
 147         const Beats adu = ad.round_up_to_beat();
 148         CPPUNIT_ASSERT_EQUAL(ad, adu);
 149
 150         // Snap to 1.5
 151         const Beats snapped = a.snap_to(Beats(1.5));
 152         CPPUNIT_ASSERT_EQUAL(snapped.get_beats(), 1);
 153         CPPUNIT_ASSERT_EQUAL(snapped.get_ticks(), Beats::PPQN / 2);
 154 }
 155
 156 void
 157 BeatsTest::convertTest()
 158 {
 159         const Beats a = Beats::ticks_at_rate(72000, 48000);
 160         CPPUNIT_ASSERT_DOUBLES_EQUAL(1, a.get_beats(), delta);
 161         CPPUNIT_ASSERT_DOUBLES_EQUAL(Beats::PPQN / 2, a.get_ticks(), delta);
 162         CPPUNIT_ASSERT_DOUBLES_EQUAL(1.5, a.to_double(), delta);
 163
 164         const Beats b = Beats::ticks_at_rate(8, 48000);
 165         CPPUNIT_ASSERT_DOUBLES_EQUAL(0, b.get_beats(), delta);
 166         CPPUNIT_ASSERT_DOUBLES_EQUAL(Beats::PPQN * 8 / 48000, b.get_ticks(), delta);
 167         CPPUNIT_ASSERT_DOUBLES_EQUAL((8 / 48000.0), b.to_double(), delta);
 168
 169         CPPUNIT_ASSERT_EQUAL(int64_t(1.5 * Beats::PPQN), a.to_ticks());
 170         CPPUNIT_ASSERT_EQUAL(int64_t(1.5 * 192), a.to_ticks(192));
 171 }