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_TEST(modargs_test_parse_boolean)29 START_TEST (modargs_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_TEST(modargs_test_parse_volume)43 START_TEST (modargs_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_TEST(modargs_test_atoi)95 START_TEST (modargs_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
104 // hexadecimal
105 ck_assert_int_eq(pa_atoi("0x100000", &value), 0);
106 ck_assert_int_eq(value, 0x100000);
107 ck_assert_int_eq(pa_atoi("-0x100000", &value), 0);
108 ck_assert_int_eq(value, -0x100000);
109
110 // invalid values
111 ck_assert_int_lt(pa_atoi("3.14", &value), 0);
112 ck_assert_int_lt(pa_atoi("7*8", &value), 0);
113 ck_assert_int_lt(pa_atoi("false", &value), 0);
114 }
115 END_TEST
116
START_TEST(modargs_test_atou)117 START_TEST (modargs_test_atou) {
118 uint32_t value;
119
120 // decimal
121 ck_assert_int_eq(pa_atou("100000", &value), 0);
122 ck_assert_int_eq(value, 100000);
123
124 // hexadecimal
125 ck_assert_int_eq(pa_atou("0x100000", &value), 0);
126 ck_assert_int_eq(value, 0x100000);
127
128 // invalid values
129 ck_assert_int_lt(pa_atou("-100000", &value), 0);
130 ck_assert_int_lt(pa_atou("-0x100000", &value), 0);
131 ck_assert_int_lt(pa_atou("3.14", &value), 0);
132 ck_assert_int_lt(pa_atou("7*8", &value), 0);
133 ck_assert_int_lt(pa_atou("false", &value), 0);
134 }
135 END_TEST
136
START_TEST(modargs_test_atol)137 START_TEST (modargs_test_atol) {
138 long value;
139
140 // decimal
141 ck_assert_int_eq(pa_atol("100000", &value), 0);
142 ck_assert_int_eq(value, 100000l);
143 ck_assert_int_eq(pa_atol("-100000", &value), 0);
144 ck_assert_int_eq(value, -100000l);
145
146 // hexadecimal
147 ck_assert_int_eq(pa_atol("0x100000", &value), 0);
148 ck_assert_int_eq(value, 0x100000l);
149 ck_assert_int_eq(pa_atol("-0x100000", &value), 0);
150 ck_assert_int_eq(value, -0x100000l);
151
152 // invalid values
153 ck_assert_int_lt(pa_atol("3.14", &value), 0);
154 ck_assert_int_lt(pa_atol("7*8", &value), 0);
155 ck_assert_int_lt(pa_atol("false", &value), 0);
156 }
157 END_TEST
158
START_TEST(modargs_test_atod)159 START_TEST (modargs_test_atod) {
160 double value;
161 double epsilon = 0.001;
162
163 // decimal
164 ck_assert_int_eq(pa_atod("100000", &value), 0);
165 ck_assert(value > 100000 - epsilon);
166 ck_assert(value < 100000 + epsilon);
167 ck_assert_int_eq(pa_atod("-100000", &value), 0);
168 ck_assert(value > -100000 - epsilon);
169 ck_assert(value < -100000 + epsilon);
170 ck_assert_int_eq(pa_atod("3.14", &value), 0);
171 ck_assert(value > 3.14 - epsilon);
172 ck_assert(value < 3.14 + epsilon);
173
174 // invalid values
175 ck_assert_int_lt(pa_atod("7*8", &value), 0);
176 ck_assert_int_lt(pa_atod("false", &value), 0);
177 }
178 END_TEST
179
START_TEST(modargs_test_replace)180 START_TEST (modargs_test_replace) {
181 char* value;
182
183 value = pa_replace("abcde", "bcd", "XYZ");
184 ck_assert_str_eq(value, "aXYZe");
185 pa_xfree(value);
186
187 value = pa_replace("abe", "b", "bab");
188 ck_assert_str_eq(value, "ababe");
189 pa_xfree(value);
190
191 value = pa_replace("abe", "c", "bab");
192 ck_assert_str_eq(value, "abe");
193 pa_xfree(value);
194
195 value = pa_replace("abcde", "bcd", "");
196 ck_assert_str_eq(value, "ae");
197 pa_xfree(value);
198 }
199 END_TEST
200
START_TEST(modargs_test_replace_fail_1)201 START_TEST (modargs_test_replace_fail_1) {
202 pa_replace(NULL, "b", "bab");
203 }
204 END_TEST
205
START_TEST(modargs_test_replace_fail_2)206 START_TEST (modargs_test_replace_fail_2) {
207 pa_replace("abe", NULL, "bab");
208 }
209 END_TEST
210
START_TEST(modargs_test_replace_fail_3)211 START_TEST (modargs_test_replace_fail_3) {
212 pa_replace("abcde", "b", NULL);
213 }
214 END_TEST
215
START_TEST(modargs_test_escape)216 START_TEST (modargs_test_escape) {
217 char* value;
218
219 value = pa_escape("abcde", "bcd");
220 ck_assert_str_eq(value, "a\\b\\c\\de");
221 pa_xfree(value);
222
223 value = pa_escape("\\", "bcd");
224 ck_assert_str_eq(value, "\\\\");
225 pa_xfree(value);
226
227 value = pa_escape("\\", NULL);
228 ck_assert_str_eq(value, "\\\\");
229 pa_xfree(value);
230 }
231 END_TEST
232
START_TEST(modargs_test_replace_fail_4)233 START_TEST (modargs_test_replace_fail_4) {
234 pa_replace("abe", "", "bab");
235 }
236 END_TEST
237
START_TEST(modargs_test_unescape)238 START_TEST (modargs_test_unescape) {
239 char* value;
240
241 value = pa_unescape(pa_xstrdup("a\\b\\c\\de"));
242 ck_assert_str_eq(value, "abcde");
243 pa_xfree(value);
244
245 value = pa_unescape(pa_xstrdup("\\\\"));
246 ck_assert_str_eq(value, "\\");
247 pa_xfree(value);
248 }
249 END_TEST
250
main(int argc,char * argv[])251 int main(int argc, char *argv[]) {
252 int failed = 0;
253 Suite *s;
254 TCase *tc;
255 SRunner *sr;
256
257 if (!getenv("MAKE_CHECK"))
258 pa_log_set_level(PA_LOG_DEBUG);
259
260 s = suite_create("Core-Util");
261
262 tc = tcase_create("core-util");
263 suite_add_tcase(s, tc);
264 tcase_add_test(tc, modargs_test_parse_boolean);
265 tcase_add_test(tc, modargs_test_parse_volume);
266 tcase_add_test(tc, modargs_test_atoi);
267 tcase_add_test(tc, modargs_test_atou);
268 tcase_add_test(tc, modargs_test_atol);
269 tcase_add_test(tc, modargs_test_atod);
270 tcase_add_test(tc, modargs_test_replace);
271 tcase_add_test_raise_signal(tc, modargs_test_replace_fail_1, SIGABRT);
272 tcase_add_test_raise_signal(tc, modargs_test_replace_fail_2, SIGABRT);
273 tcase_add_test_raise_signal(tc, modargs_test_replace_fail_3, SIGABRT);
274 tcase_add_test_raise_signal(tc, modargs_test_replace_fail_4, SIGABRT);
275 tcase_add_test(tc, modargs_test_escape);
276 tcase_add_test(tc, modargs_test_unescape);
277
278 sr = srunner_create(s);
279 srunner_run_all(sr, CK_NORMAL);
280 failed = srunner_ntests_failed(sr);
281 srunner_free(sr);
282
283 return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
284 }
285