1/***
2  This file is part of PulseAudio.
3
4  PulseAudio is free software; you can redistribute it and/or modify
5  it under the terms of the GNU Lesser General Public License as published
6  by the Free Software Foundation; either version 2.1 of the License,
7  or (at your option) any later version.
8
9  PulseAudio is distributed in the hope that it will be useful, but
10  WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  General Public License for more details.
13
14  You should have received a copy of the GNU Lesser General Public License
15  along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
16***/
17
18#ifdef HAVE_CONFIG_H
19#include <config.h>
20#endif
21
22#include <signal.h>
23
24#include <check.h>
25
26#include <pulse/xmalloc.h>
27#include <pulsecore/core-util.h>
28
29START_TEST (test_parse_boolean) {
30    ck_assert_int_eq(pa_parse_boolean("true"), true);
31    ck_assert_int_eq(pa_parse_boolean("yes"), true);
32    ck_assert_int_eq(pa_parse_boolean("1"), true);
33
34    ck_assert_int_eq(pa_parse_boolean("false"), false);
35    ck_assert_int_eq(pa_parse_boolean("no"), false);
36    ck_assert_int_eq(pa_parse_boolean("0"), false);
37
38    ck_assert_int_eq(pa_parse_boolean("maybe"), -1);
39    ck_assert_int_eq(pa_parse_boolean("42"), -1);
40}
41END_TEST
42
43START_TEST (test_parse_volume) {
44    pa_volume_t value;
45
46    // dB volumes
47    ck_assert_int_eq(pa_parse_volume("-20dB", &value), 0);
48    ck_assert_int_eq(value, 30419);
49    ck_assert_int_eq(pa_parse_volume("-10dB", &value), 0);
50    ck_assert_int_eq(value, 44649);
51    ck_assert_int_eq(pa_parse_volume("-1dB", &value), 0);
52    ck_assert_int_eq(value, 63069);
53    ck_assert_int_eq(pa_parse_volume("0dB", &value), 0);
54    ck_assert_int_eq(value, 65536);
55    ck_assert_int_eq(pa_parse_volume("1dB", &value), 0);
56    ck_assert_int_eq(value, 68100);
57    ck_assert_int_eq(pa_parse_volume("10dB", &value), 0);
58    ck_assert_int_eq(value, 96194);
59
60    // lowercase db
61    ck_assert_int_eq(pa_parse_volume("10db", &value), 0);
62    ck_assert_int_eq(value, 96194);
63
64    // percentage volumes
65    ck_assert_int_eq(pa_parse_volume("0%", &value), 0);
66    ck_assert_int_eq(value, 0);
67    ck_assert_int_eq(pa_parse_volume("50%", &value), 0);
68    ck_assert_int_eq(value, 32768);
69    ck_assert_int_eq(pa_parse_volume("100%", &value), 0);
70    ck_assert_int_eq(value, 65536);
71    ck_assert_int_eq(pa_parse_volume("150%", &value), 0);
72    ck_assert_int_eq(value, 98304);
73
74    // integer volumes`
75    ck_assert_int_eq(pa_parse_volume("0", &value), 0);
76    ck_assert_int_eq(value, 0);
77    ck_assert_int_eq(pa_parse_volume("100", &value), 0);
78    ck_assert_int_eq(value, 100);
79    ck_assert_int_eq(pa_parse_volume("1000", &value), 0);
80    ck_assert_int_eq(value, 1000);
81    ck_assert_int_eq(pa_parse_volume("65536", &value), 0);
82    ck_assert_int_eq(value, 65536);
83    ck_assert_int_eq(pa_parse_volume("100000", &value), 0);
84    ck_assert_int_eq(value, 100000);
85
86    // invalid volumes
87    ck_assert_int_lt(pa_parse_volume("", &value), 0);
88    ck_assert_int_lt(pa_parse_volume("-2", &value), 0);
89    ck_assert_int_lt(pa_parse_volume("on", &value), 0);
90    ck_assert_int_lt(pa_parse_volume("off", &value), 0);
91    ck_assert_int_lt(pa_parse_volume("none", &value), 0);
92}
93END_TEST
94
95START_TEST (test_atoi) {
96    int32_t value;
97
98    // decimal
99    ck_assert_int_eq(pa_atoi("100000", &value), 0);
100    ck_assert_int_eq(value, 100000);
101    ck_assert_int_eq(pa_atoi("-100000", &value), 0);
102    ck_assert_int_eq(value, -100000);
103    ck_assert_int_eq(pa_atoi("010", &value), 0);
104    ck_assert_int_eq(value, 10);
105    ck_assert_int_eq(pa_atoi("-010", &value), 0);
106    ck_assert_int_eq(value, -10);
107
108    // hexadecimal
109    ck_assert_int_eq(pa_atoi("0x100000", &value), 0);
110    ck_assert_int_eq(value, 0x100000);
111    ck_assert_int_eq(pa_atoi("-0x100000", &value), 0);
112    ck_assert_int_eq(value, -0x100000);
113
114    // invalid values
115    ck_assert_int_lt(pa_atoi("3.14", &value), 0);
116    ck_assert_int_lt(pa_atoi("7*8", &value), 0);
117    ck_assert_int_lt(pa_atoi("false", &value), 0);
118    ck_assert_int_lt(pa_atoi("10000000000", &value), 0);
119}
120END_TEST
121
122START_TEST (test_atou) {
123    uint32_t value;
124
125    // decimal
126    ck_assert_int_eq(pa_atou("100000", &value), 0);
127    ck_assert_int_eq(value, 100000);
128    ck_assert_int_eq(pa_atou("010", &value), 0);
129    ck_assert_int_eq(value, 10);
130
131    // hexadecimal
132    ck_assert_int_eq(pa_atou("0x100000", &value), 0);
133    ck_assert_int_eq(value, 0x100000);
134
135    // invalid values
136    ck_assert_int_lt(pa_atou("-100000", &value), 0);
137    ck_assert_int_lt(pa_atou("-0x100000", &value), 0);
138    ck_assert_int_lt(pa_atou("3.14", &value), 0);
139    ck_assert_int_lt(pa_atou("7*8", &value), 0);
140    ck_assert_int_lt(pa_atou("false", &value), 0);
141    ck_assert_int_lt(pa_atou("10000000000", &value), 0);
142}
143END_TEST
144
145START_TEST (test_atou64) {
146    uint64_t value;
147
148    // decimal
149    ck_assert_int_eq(pa_atou64("100000", &value), 0);
150    ck_assert_int_eq(value, 100000);
151    ck_assert_int_eq(pa_atou64("010", &value), 0);
152    ck_assert_int_eq(value, 10);
153    ck_assert_int_eq(pa_atou64("10000000000", &value), 0);
154    ck_assert_int_eq(value, 10000000000);
155
156    // hexadecimal
157    ck_assert_int_eq(pa_atou64("0x100000", &value), 0);
158    ck_assert_int_eq(value, 0x100000);
159
160    // invalid values
161    ck_assert_int_lt(pa_atou64("-100000", &value), 0);
162    ck_assert_int_lt(pa_atou64("-0x100000", &value), 0);
163    ck_assert_int_lt(pa_atou64("3.14", &value), 0);
164    ck_assert_int_lt(pa_atou64("7*8", &value), 0);
165    ck_assert_int_lt(pa_atou64("false", &value), 0);
166}
167END_TEST
168
169START_TEST (test_atol) {
170    long value;
171
172    // decimal
173    ck_assert_int_eq(pa_atol("100000", &value), 0);
174    ck_assert_int_eq(value, 100000l);
175    ck_assert_int_eq(pa_atol("-100000", &value), 0);
176    ck_assert_int_eq(value, -100000l);
177    ck_assert_int_eq(pa_atol("010", &value), 0);
178    ck_assert_int_eq(value, 10);
179    ck_assert_int_eq(pa_atol("-010", &value), 0);
180    ck_assert_int_eq(value, -10);
181
182    // hexadecimal
183    ck_assert_int_eq(pa_atol("0x100000", &value), 0);
184    ck_assert_int_eq(value, 0x100000l);
185    ck_assert_int_eq(pa_atol("-0x100000", &value), 0);
186    ck_assert_int_eq(value, -0x100000l);
187
188    // invalid values
189    ck_assert_int_lt(pa_atol("3.14", &value), 0);
190    ck_assert_int_lt(pa_atol("7*8", &value), 0);
191    ck_assert_int_lt(pa_atol("false", &value), 0);
192}
193END_TEST
194
195START_TEST (test_atoi64) {
196    int64_t value;
197
198    // decimal
199    ck_assert_int_eq(pa_atoi64("100000", &value), 0);
200    ck_assert_int_eq(value, 100000);
201    ck_assert_int_eq(pa_atoi64("-100000", &value), 0);
202    ck_assert_int_eq(value, -100000);
203    ck_assert_int_eq(pa_atoi64("010", &value), 0);
204    ck_assert_int_eq(value, 10);
205    ck_assert_int_eq(pa_atoi64("-010", &value), 0);
206    ck_assert_int_eq(value, -10);
207    ck_assert_int_eq(pa_atoi64("10000000000", &value), 0);
208    ck_assert_int_eq(value, 10000000000);
209
210    // hexadecimal
211    ck_assert_int_eq(pa_atoi64("0x100000", &value), 0);
212    ck_assert_int_eq(value, 0x100000);
213    ck_assert_int_eq(pa_atoi64("-0x100000", &value), 0);
214    ck_assert_int_eq(value, -0x100000);
215
216    // invalid values
217    ck_assert_int_lt(pa_atoi64("3.14", &value), 0);
218    ck_assert_int_lt(pa_atoi64("7*8", &value), 0);
219    ck_assert_int_lt(pa_atoi64("false", &value), 0);
220}
221END_TEST
222
223START_TEST (test_atod) {
224    double value;
225    double epsilon = 0.001;
226
227    // decimal
228    ck_assert_int_eq(pa_atod("100000", &value), 0);
229    ck_assert(value > 100000 - epsilon);
230    ck_assert(value < 100000 + epsilon);
231    ck_assert_int_eq(pa_atod("-100000", &value), 0);
232    ck_assert(value > -100000 - epsilon);
233    ck_assert(value < -100000 + epsilon);
234    ck_assert_int_eq(pa_atod("3.14", &value), 0);
235    ck_assert(value > 3.14 - epsilon);
236    ck_assert(value < 3.14 + epsilon);
237
238    // invalid values
239    ck_assert_int_lt(pa_atod("7*8", &value), 0);
240    ck_assert_int_lt(pa_atod("false", &value), 0);
241}
242END_TEST
243
244START_TEST (test_replace) {
245    char* value;
246
247    value = pa_replace("abcde", "bcd", "XYZ");
248    ck_assert_str_eq(value, "aXYZe");
249    pa_xfree(value);
250
251    value = pa_replace("abe", "b", "bab");
252    ck_assert_str_eq(value, "ababe");
253    pa_xfree(value);
254
255    value = pa_replace("abe", "c", "bab");
256    ck_assert_str_eq(value, "abe");
257    pa_xfree(value);
258
259    value = pa_replace("abcde", "bcd", "");
260    ck_assert_str_eq(value, "ae");
261    pa_xfree(value);
262}
263END_TEST
264
265START_TEST (test_replace_fail_1) {
266    pa_replace(NULL, "b", "bab");
267}
268END_TEST
269
270START_TEST (test_replace_fail_2) {
271    pa_replace("abe", NULL, "bab");
272}
273END_TEST
274
275START_TEST (test_replace_fail_3) {
276    pa_replace("abcde", "b", NULL);
277}
278END_TEST
279
280START_TEST (test_escape) {
281    char* value;
282
283    value = pa_escape("abcde", "bcd");
284    ck_assert_str_eq(value, "a\\b\\c\\de");
285    pa_xfree(value);
286
287    value = pa_escape("\\", "bcd");
288    ck_assert_str_eq(value, "\\\\");
289    pa_xfree(value);
290
291    value = pa_escape("\\", NULL);
292    ck_assert_str_eq(value, "\\\\");
293    pa_xfree(value);
294}
295END_TEST
296
297START_TEST (test_replace_fail_4) {
298    pa_replace("abe", "", "bab");
299}
300END_TEST
301
302START_TEST (test_unescape) {
303    char* value;
304
305    value = pa_unescape(pa_xstrdup("a\\b\\c\\de"));
306    ck_assert_str_eq(value, "abcde");
307    pa_xfree(value);
308
309    value = pa_unescape(pa_xstrdup("\\\\"));
310    ck_assert_str_eq(value, "\\");
311    pa_xfree(value);
312}
313END_TEST
314
315int main(int argc, char *argv[]) {
316    int failed = 0;
317    Suite *s;
318    TCase *tc;
319    SRunner *sr;
320
321    if (!getenv("MAKE_CHECK"))
322        pa_log_set_level(PA_LOG_DEBUG);
323
324    s = suite_create("Core-Util");
325
326    tc = tcase_create("core-util");
327    suite_add_tcase(s, tc);
328    tcase_add_test(tc, test_parse_boolean);
329    tcase_add_test(tc, test_parse_volume);
330    tcase_add_test(tc, test_atoi);
331    tcase_add_test(tc, test_atou);
332    tcase_add_test(tc, test_atou64);
333    tcase_add_test(tc, test_atol);
334    tcase_add_test(tc, test_atoi64);
335    tcase_add_test(tc, test_atod);
336    tcase_add_test(tc, test_replace);
337    tcase_add_test_raise_signal(tc, test_replace_fail_1, SIGABRT);
338    tcase_add_test_raise_signal(tc, test_replace_fail_2, SIGABRT);
339    tcase_add_test_raise_signal(tc, test_replace_fail_3, SIGABRT);
340    tcase_add_test_raise_signal(tc, test_replace_fail_4, SIGABRT);
341    tcase_add_test(tc, test_escape);
342    tcase_add_test(tc, test_unescape);
343
344    sr = srunner_create(s);
345    srunner_run_all(sr, CK_NORMAL);
346    failed = srunner_ntests_failed(sr);
347    srunner_free(sr);
348
349    return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
350}
351