1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
#include "common/common_pch.h"
#include "common/timestamp.h"
#include "tests/unit/init.h"
namespace {
TEST(BasicTimecode, Creation) {
EXPECT_EQ( 1ll, timestamp_c::factor(1).to_ns());
EXPECT_EQ( 1ll, timestamp_c::ns(1).to_ns());
EXPECT_EQ( 1000ll, timestamp_c::us(1).to_ns());
EXPECT_EQ( 1000000ll, timestamp_c::ms(1).to_ns());
EXPECT_EQ( 1000000000ll, timestamp_c::s(1).to_ns());
EXPECT_EQ( 60000000000ll, timestamp_c::m(1).to_ns());
EXPECT_EQ(3600000000000ll, timestamp_c::h(1).to_ns());
EXPECT_EQ( 11111ll, timestamp_c::mpeg(1).to_ns());
}
TEST(BasicTimecode, Deconstruction) {
EXPECT_EQ(7204003002001ll, timestamp_c::ns(7204003002001ll).to_ns());
EXPECT_EQ( 7204003002ll, timestamp_c::ns(7204003002001ll).to_us());
EXPECT_EQ( 7204003ll, timestamp_c::ns(7204003002001ll).to_ms());
EXPECT_EQ( 7204ll, timestamp_c::ns(7204003002001ll).to_s());
EXPECT_EQ( 120ll, timestamp_c::ns(7204003002001ll).to_m());
EXPECT_EQ( 2ll, timestamp_c::ns(7204003002001ll).to_h());
EXPECT_EQ( 648360270ll, timestamp_c::ns(7204003002001ll).to_mpeg());
}
TEST(BasicTimecode, ArithmeticBothValid) {
EXPECT_TRUE((timestamp_c::s(2) + timestamp_c::us(500000)).valid());
EXPECT_TRUE((timestamp_c::s(2) - timestamp_c::us(500000)).valid());
EXPECT_TRUE((timestamp_c::us(1250000) * timestamp_c::factor(2)).valid());
EXPECT_TRUE((timestamp_c::us(9900000) / timestamp_c::factor(3)).valid());
EXPECT_TRUE(timestamp_c::s(-3).abs().valid());
}
TEST(BasicTimecode, ArithmenticResults) {
EXPECT_EQ(timestamp_c::ms(2500), timestamp_c::s(2) + timestamp_c::us(500000));
EXPECT_EQ(timestamp_c::ms(1500), timestamp_c::s(2) - timestamp_c::us(500000));
EXPECT_EQ(timestamp_c::ms(2500), timestamp_c::us(1250000) * timestamp_c::factor(2));
EXPECT_EQ(timestamp_c::ms(3300), timestamp_c::us(9900000) / timestamp_c::factor(3));
EXPECT_EQ(timestamp_c::s(-3).abs(), timestamp_c::s(3));
EXPECT_EQ(timestamp_c::s(-3).abs(), timestamp_c::s(3).abs());
EXPECT_EQ(timestamp_c::s(-3).negate(), timestamp_c::s(+3));
EXPECT_EQ(timestamp_c::s(+3).negate(), timestamp_c::s(-3));
}
TEST(BasicTimecode, ArithmenticLHSInvalid) {
EXPECT_FALSE((timestamp_c{} + timestamp_c::m(2)).valid());
EXPECT_FALSE((timestamp_c{} - timestamp_c::m(3)).valid());
EXPECT_FALSE((timestamp_c{} * timestamp_c::factor(2)).valid());
EXPECT_FALSE((timestamp_c{} / timestamp_c::factor(4)).valid());
}
TEST(BasicTimecode, ArithmenticRHSInvalid) {
EXPECT_FALSE((timestamp_c::m(2) + timestamp_c{}).valid());
EXPECT_FALSE((timestamp_c::m(3) - timestamp_c{}).valid());
EXPECT_FALSE((timestamp_c::factor(2) * timestamp_c{}).valid());
EXPECT_FALSE((timestamp_c::factor(4) / timestamp_c{}).valid());
}
TEST(BasicTimecode, ArithmenticBothInvalid) {
EXPECT_FALSE((timestamp_c{} + timestamp_c{}).valid());
EXPECT_FALSE((timestamp_c{} - timestamp_c{}).valid());
EXPECT_FALSE((timestamp_c{} * timestamp_c{}).valid());
EXPECT_FALSE((timestamp_c{} / timestamp_c{}).valid());
}
TEST(BasicTimecode, ComparisonBothValid) {
EXPECT_TRUE( timestamp_c::ms(2500) < timestamp_c::s(3));
EXPECT_TRUE( timestamp_c::ms(2500) <= timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(2500) > timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(2500) >= timestamp_c::s(3));
EXPECT_TRUE( timestamp_c::ms(2500) != timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(2500) == timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(3000) < timestamp_c::s(3));
EXPECT_TRUE( timestamp_c::ms(3000) <= timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(3000) > timestamp_c::s(3));
EXPECT_TRUE( timestamp_c::ms(3000) >= timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(3000) != timestamp_c::s(3));
EXPECT_TRUE( timestamp_c::ms(3000) == timestamp_c::s(3));
EXPECT_FALSE(timestamp_c::ms(4000) <= timestamp_c::s(3));
EXPECT_TRUE( timestamp_c::ms(4000) > timestamp_c::s(3));
}
TEST(BasicTimecode, ComparisonLHSInvalid) {
EXPECT_TRUE( timestamp_c{} < timestamp_c::ns(3));
EXPECT_FALSE(timestamp_c{} == timestamp_c::ns(3));
}
TEST(BasicTimecode, ComparisonRHSInvalid) {
EXPECT_FALSE(timestamp_c::ns(3) < timestamp_c{});
EXPECT_FALSE(timestamp_c::ns(3) == timestamp_c{});
}
TEST(BasicTimecode, ComparisonBothInvalid) {
EXPECT_FALSE(timestamp_c{} < timestamp_c{});
EXPECT_TRUE( timestamp_c{} == timestamp_c{});
}
TEST(BasicTimecode, ThrowOnDeconstructionOfInvalid) {
EXPECT_THROW(timestamp_c{}.to_ns(), std::domain_error);
EXPECT_THROW(timestamp_c{}.to_us(), std::domain_error);
EXPECT_THROW(timestamp_c{}.to_ms(), std::domain_error);
EXPECT_THROW(timestamp_c{}.to_s(), std::domain_error);
EXPECT_THROW(timestamp_c{}.to_m(), std::domain_error);
EXPECT_THROW(timestamp_c{}.to_h(), std::domain_error);
EXPECT_THROW(timestamp_c{}.to_mpeg(), std::domain_error);
EXPECT_NO_THROW(timestamp_c{}.to_ns(1));
}
TEST(BasicTimecode, ConstructFromSamples) {
EXPECT_EQ( 0, timestamp_c::samples( 0, 48000).to_ns());
EXPECT_EQ( 416645833, timestamp_c::samples( 19999, 48000).to_ns());
EXPECT_EQ( 416666667, timestamp_c::samples( 20000, 48000).to_ns());
EXPECT_EQ(1000000000, timestamp_c::samples( 48000, 48000).to_ns());
EXPECT_EQ(2572000000, timestamp_c::samples(123456, 48000).to_ns());
EXPECT_THROW(timestamp_c::samples(123, 0), std::domain_error);
}
TEST(BasicTimecode, DeconstructToSamples) {
EXPECT_EQ( 0, timestamp_c::ns( 0).to_samples(48000));
EXPECT_EQ( 19999, timestamp_c::ns( 416645833).to_samples(48000));
EXPECT_EQ( 20000, timestamp_c::ns( 416666667).to_samples(48000));
EXPECT_EQ( 48000, timestamp_c::ns(1000000000).to_samples(48000));
EXPECT_EQ(123456, timestamp_c::ns(2572000000).to_samples(48000));
EXPECT_THROW(timestamp_c::ns(123).to_samples(0), std::domain_error);
}
TEST(BasicTimecode, Resetting) {
auto v = timestamp_c::ns(1);
EXPECT_TRUE(v.valid());
EXPECT_NO_THROW(v.to_ns());
v.reset();
EXPECT_FALSE(v.valid());
EXPECT_THROW(v.to_ns(), std::domain_error);
}
TEST(BasicTimecode, MinMax) {
EXPECT_TRUE(timestamp_c::min() < timestamp_c::max());
EXPECT_TRUE(timestamp_c::min() == timestamp_c::ns(std::numeric_limits<int64_t>::min()));
EXPECT_TRUE(timestamp_c::max() == timestamp_c::ns(std::numeric_limits<int64_t>::max()));
EXPECT_TRUE(timestamp_c{}.value_or_min() == timestamp_c::min());
EXPECT_TRUE(timestamp_c{}.value_or_max() == timestamp_c::max());
EXPECT_TRUE(timestamp_c{}.value_or_zero() == timestamp_c::ns(0));
EXPECT_TRUE(timestamp_c::ns(1).value_or_min() == timestamp_c::ns(1));
EXPECT_TRUE(timestamp_c::ns(1).value_or_max() == timestamp_c::ns(1));
EXPECT_TRUE(timestamp_c::ns(1).value_or_zero() == timestamp_c::ns(1));
}
}
|
