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
START_TESTnull29 START_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 }
41 END_TEST
42
START_TESTnull43 START_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 }
93 END_TEST
94
START_TESTnull95 START_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 }
120 END_TEST
121
START_TESTnull122 START_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 }
143 END_TEST
144
START_TESTnull145 START_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 }
167 END_TEST
168
START_TESTnull169 START_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 }
193 END_TEST
194
START_TESTnull195 START_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 }
221 END_TEST
222
START_TESTnull223 START_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 }
242 END_TEST
243
START_TESTnull244 START_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 }
263 END_TEST
264
START_TESTnull265 START_TEST (test_replace_fail_1) {
266 pa_replace(NULL, "b", "bab");
267 }
268 END_TEST
269
START_TESTnull270 START_TEST (test_replace_fail_2) {
271 pa_replace("abe", NULL, "bab");
272 }
273 END_TEST
274
START_TESTnull275 START_TEST (test_replace_fail_3) {
276 pa_replace("abcde", "b", NULL);
277 }
278 END_TEST
279
START_TESTnull280 START_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 }
295 END_TEST
296
START_TESTnull297 START_TEST (test_replace_fail_4) {
298 pa_replace("abe", "", "bab");
299 }
300 END_TEST
301
START_TESTnull302 START_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 }
313 END_TEST
314
main(int argc, char *argv[])315 int 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