libs/evoral/test/BeatsTest.cpp

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