Line data Source code
1 : /*
2 : * Present - Date/Time Library
3 : *
4 : * Tests for the MonthDelta C++ class and C-compatible methods
5 : *
6 : * Licensed under the MIT License.
7 : * For details, see LICENSE.
8 : */
9 :
10 : #include "catch.hpp"
11 : #include "test-utils.hpp"
12 :
13 : #include "present.h"
14 :
15 : /**
16 : * Shortcut macro to compare the number of months.
17 : * Expects that the delta is called "d".
18 : */
19 : #define IS(test_delta_months) \
20 : CHECK(d.data_.delta_months == test_delta_months);
21 :
22 :
23 : /**
24 : * This test case tests all of the "from_" methods (which also tests the C
25 : * "MonthDelta_from_..." methods).
26 : */
27 4 : TEST_CASE("MonthDelta creators", "[month-delta]") {
28 : MonthDelta d;
29 :
30 3 : SECTION("creating from a number of months") {
31 1 : d = MonthDelta::from_months(1);
32 1 : IS(1);
33 1 : d = MonthDelta::from_months(-1);
34 1 : IS(-1);
35 1 : d = MonthDelta::from_months(0);
36 1 : IS(0);
37 1 : d = MonthDelta::from_months(2147483647);
38 1 : IS(2147483647);
39 1 : d = MonthDelta::from_months(-2147483647);
40 1 : IS(-2147483647);
41 :
42 1 : d = MonthDelta_from_months(6);
43 1 : IS(6);
44 :
45 1 : MonthDelta_ptr_from_months(&d, -8);
46 1 : IS(-8);
47 3 : }
48 :
49 3 : SECTION("creating from a number of years") {
50 1 : d = MonthDelta::from_years(1);
51 1 : IS(12);
52 1 : d = MonthDelta::from_years(-2);
53 1 : IS(-24);
54 1 : d = MonthDelta::from_years(120);
55 1 : IS(1440);
56 1 : d = MonthDelta::from_years(-3600);
57 1 : IS(-43200);
58 1 : d = MonthDelta::from_years(0);
59 1 : IS(0);
60 1 : d = MonthDelta::from_years(32767);
61 1 : IS(393204);
62 1 : d = MonthDelta::from_years(-32767);
63 1 : IS(-393204);
64 :
65 1 : d = MonthDelta_from_years(5);
66 1 : IS(60);
67 :
68 1 : MonthDelta_ptr_from_years(&d, -8);
69 1 : IS(-96);
70 3 : }
71 :
72 3 : SECTION("creating with no months") {
73 1 : d = MonthDelta::zero();
74 1 : IS(0);
75 :
76 1 : d = MonthDelta_zero();
77 1 : IS(0);
78 :
79 1 : MonthDelta_ptr_zero(&d);
80 1 : IS(0);
81 3 : }
82 3 : }
83 :
84 2 : TEST_CASE("MonthDelta accessors", "[month-delta]") {
85 1 : MonthDelta d1 = MonthDelta::from_months(3),
86 1 : d2 = MonthDelta::from_months(100),
87 1 : d3 = MonthDelta::from_months(-10),
88 1 : d4 = MonthDelta::from_months(-20),
89 1 : d5 = MonthDelta::zero();
90 :
91 1 : CHECK(d1.months() == 3);
92 1 : CHECK(d2.months() == 100);
93 1 : CHECK(d3.months() == -10);
94 1 : CHECK(d4.months() == -20);
95 1 : CHECK(d5.months() == 0);
96 :
97 1 : CHECK(d1.years() == 0);
98 1 : CHECK(d2.years() == 8);
99 1 : CHECK(d3.years() == 0);
100 1 : CHECK(d4.years() == -1);
101 1 : CHECK(d5.years() == 0);
102 :
103 1 : CHECK(d1.years_decimal() == 0.25);
104 1 : CHECK(d2.years_decimal() == 8.333333333333334);
105 1 : CHECK(d3.years_decimal() == -0.8333333333333334);
106 1 : CHECK(d4.years_decimal() == -1.6666666666666667);
107 1 : CHECK(d5.years_decimal() == 0.0);
108 1 : }
109 :
110 7 : TEST_CASE("MonthDelta arithmetic operators", "[month-delta]") {
111 6 : MonthDelta d1 = MonthDelta::from_months(4),
112 6 : d2 = MonthDelta::from_months(-15),
113 6 : d3 = MonthDelta::zero();
114 :
115 6 : SECTION("is_negative()") {
116 1 : CHECK(!d1.is_negative());
117 1 : CHECK(d2.is_negative());
118 1 : CHECK(!d3.is_negative());
119 6 : }
120 :
121 6 : SECTION("negate()") {
122 1 : d1.negate();
123 1 : CHECK(d1.months() == -4);
124 1 : CHECK(d1.years() == 0);
125 1 : d1.negate();
126 1 : CHECK(d1.months() == 4);
127 1 : CHECK(d1.years() == 0);
128 :
129 1 : d2.negate();
130 1 : CHECK(d2.months() == 15);
131 1 : CHECK(d2.years() == 1);
132 1 : d2.negate();
133 1 : CHECK(d2.months() == -15);
134 1 : CHECK(d2.years() == -1);
135 :
136 1 : d3.negate();
137 1 : CHECK(d3.months() == 0);
138 1 : CHECK(d3.years() == 0);
139 1 : d3.negate();
140 1 : CHECK(d3.months() == 0);
141 1 : CHECK(d3.years() == 0);
142 6 : }
143 :
144 6 : SECTION("operator-") {
145 : MonthDelta d;
146 :
147 1 : d = -d1;
148 1 : IS(-4);
149 1 : d = -d2;
150 1 : IS(15);
151 1 : d = -d3;
152 1 : IS(0);
153 6 : }
154 :
155 6 : SECTION("operator++ / operator--") {
156 : MonthDelta d;
157 :
158 1 : d = MonthDelta::from_months(5);
159 1 : IS(5);
160 1 : CHECK((d++).months() == 5);
161 1 : IS(6);
162 1 : CHECK((++d).months() == 7);
163 1 : IS(7);
164 1 : CHECK((d--).months() == 7);
165 1 : IS(6);
166 1 : CHECK((--d).months() == 5);
167 1 : IS(5);
168 6 : }
169 :
170 6 : SECTION("scaling") {
171 : MonthDelta d;
172 :
173 1 : d = MonthDelta::from_months(5);
174 1 : IS(5);
175 1 : d *= 6;
176 1 : IS(30);
177 1 : d /= 10;
178 1 : IS(3);
179 :
180 1 : d = MonthDelta::from_months(-10);
181 1 : IS(-10);
182 1 : d *= 6;
183 1 : IS(-60);
184 1 : d /= 25;
185 1 : IS(-2);
186 :
187 1 : d = MonthDelta::from_months(9);
188 1 : IS(9);
189 1 : CHECK((d * 3).months() == 27);
190 1 : IS(9);
191 1 : CHECK((d * -5).months() == -45);
192 1 : IS(9);
193 1 : CHECK((d / 4).months() == 2);
194 1 : IS(9);
195 1 : CHECK((d / -3).months() == -3);
196 1 : IS(9);
197 :
198 1 : d = MonthDelta::from_months(-43);
199 1 : IS(-43);
200 1 : CHECK((d * 2).months() == -86);
201 1 : IS(-43);
202 1 : CHECK((d * -4).months() == 172);
203 1 : IS(-43);
204 1 : CHECK((d / 6).months() == -7);
205 1 : IS(-43);
206 1 : CHECK((d / -7).months() == 6);
207 1 : IS(-43);
208 6 : }
209 :
210 6 : SECTION("addition/subtraction") {
211 : MonthDelta d;
212 :
213 1 : d = MonthDelta::from_months(5);
214 1 : IS(5);
215 1 : d += MonthDelta::from_months(8);
216 1 : IS(13);
217 1 : d += MonthDelta::from_months(-4);
218 1 : IS(9);
219 1 : d -= MonthDelta::from_months(12);
220 1 : IS(-3);
221 1 : d -= MonthDelta::from_months(-5);
222 1 : IS(2);
223 :
224 1 : d = MonthDelta::from_months(-13);
225 1 : IS(-13);
226 1 : CHECK((d + MonthDelta::from_months(4)).months() == -9);
227 1 : IS(-13);
228 1 : CHECK((d + MonthDelta::from_months(-7)).months() == -20);
229 1 : IS(-13);
230 1 : CHECK((d - MonthDelta::from_months(8)).months() == -21);
231 1 : IS(-13);
232 1 : CHECK((d - MonthDelta::from_months(-34)).months() == 21);
233 1 : IS(-13);
234 6 : }
235 6 : }
236 :
237 2 : TEST_CASE("MonthDelta comparison operators", "[month-delta]") {
238 1 : MonthDelta d1 = MonthDelta::from_months(19),
239 1 : d2 = MonthDelta::from_months(21),
240 1 : d3 = MonthDelta::from_months(-13),
241 1 : d4 = MonthDelta::from_months(-13),
242 1 : d5 = MonthDelta::zero();
243 :
244 1 : CHECK(MonthDelta::compare(d1, d2) < 0);
245 1 : CHECK(MonthDelta::compare(d1, d3) > 0);
246 1 : CHECK(MonthDelta::compare(d1, d5) > 0);
247 1 : CHECK(MonthDelta::compare(d3, d4) == 0);
248 1 : CHECK(MonthDelta::compare(d4, d3) == 0);
249 1 : CHECK(MonthDelta::compare(d5, d5) == 0);
250 :
251 1 : CHECK(d3 == d4);
252 1 : CHECK(d4 == d3);
253 1 : CHECK(!(d1 == d2));
254 1 : CHECK(!(d1 == d5));
255 1 : CHECK(d1 != d2);
256 1 : CHECK(d5 != d1);
257 :
258 1 : CHECK(d1 < d2);
259 1 : CHECK(d3 < d1);
260 1 : CHECK(!(d5 < d4));
261 1 : CHECK(!(d3 < d4));
262 :
263 1 : CHECK(d1 <= d2);
264 1 : CHECK(d3 <= d2);
265 1 : CHECK(!(d5 <= d4));
266 1 : CHECK(d3 <= d4);
267 :
268 1 : CHECK(d1 > d3);
269 1 : CHECK(d2 > d1);
270 1 : CHECK(d5 > d3);
271 1 : CHECK(!(d3 > d4));
272 1 : CHECK(!(d3 > d2));
273 1 : CHECK(!(d1 > d2));
274 :
275 1 : CHECK(d1 >= d3);
276 1 : CHECK(d2 >= d1);
277 1 : CHECK(d5 >= d3);
278 1 : CHECK(d3 >= d4);
279 1 : CHECK(!(d5 >= d2));
280 4 : }
281 :
|
