1 /* $NetBSD: t_usbhid.c,v 1.12 2016/08/17 12:10:42 jakllsch Exp $ */
4 * Copyright (c) 2016 Jonathan A. Kollasch
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
26 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include <sys/cdefs.h>
30 __RCSID("$NetBSD: t_usbhid.c,v 1.12 2016/08/17 12:10:42 jakllsch Exp $");
43 ATF_TC(check_hid_logical_range);
44 ATF_TC(check_hid_physical_range);
45 ATF_TC(check_hid_usage);
46 ATF_TC(check_hid_get_data);
47 ATF_TC(check_hid_set_data);
48 ATF_TC(check_parse_just_pop);
50 #define MYd_ATF_CHECK_EQ(d, v) \
51 ATF_CHECK_EQ_MSG(d, v, "== %d", (d))
53 #define MYu_ATF_CHECK_EQ(d, v) \
54 ATF_CHECK_EQ_MSG(d, v, "== %u", (d))
56 #define MYx_ATF_CHECK_EQ(d, v) \
57 ATF_CHECK_EQ_MSG(d, v, "== 0x%x", (d))
59 #include "hid_test_data.c"
61 ATF_TC_HEAD(check_hid_usage, tc)
64 atf_tc_set_md_var(tc, "descr", "Test libusbhid usage.c");
67 ATF_TC_BODY(check_hid_usage, tc)
69 char usages_path[PATH_MAX];
71 (void)strlcpy(usages_path, atf_tc_get_config_var(tc, "srcdir"),
73 (void)strlcat(usages_path, "/test_usb_hid_usages",
76 hid_init(usages_path);
78 ATF_CHECK_STREQ("t_usbhid_page", hid_usage_page(0xff1b));
79 ATF_CHECK_EQ((uint32_t)hid_parse_usage_page("t_usbhid_page"), 0xff1b);
81 ATF_CHECK_STREQ("t_usbhid_usage", hid_usage_in_page(0xff1bff2a));
82 ATF_CHECK_EQ((uint32_t)hid_parse_usage_in_page(
83 "t_usbhid_page:t_usbhid_usage"), 0xff1bff2a);
85 ATF_CHECK_STREQ("Quick_zephyrs_blow_vexing_daft_Jim_",
86 hid_usage_page(0xff2a));
87 ATF_CHECK_EQ((uint32_t)hid_parse_usage_page(
88 "Quick_zephyrs_blow_vexing_daft_Jim_"), 0xff2a);
90 ATF_CHECK_STREQ("Usage_ID_Zero_%", hid_usage_in_page(0xff2a0000));
91 ATF_CHECK_EQ((uint32_t)hid_parse_usage_in_page(
92 "Quick_zephyrs_blow_vexing_daft_Jim_:Usage_ID_Zero_%"),
95 //ATF_CHECK_STREQ("Usage_ID_0_%", hid_usage_in_page(0xff2a0000));
96 ATF_CHECK_EQ((uint32_t)hid_parse_usage_in_page(
97 "Quick_zephyrs_blow_vexing_daft_Jim_:Usage_ID_0_%"), 0xff2a0000);
99 ATF_CHECK_STREQ("Usage_ID_65535_%", hid_usage_in_page(0xff2affff));
100 ATF_CHECK_EQ((uint32_t)hid_parse_usage_in_page(
101 "Quick_zephyrs_blow_vexing_daft_Jim_:Usage_ID_65535_%"),
104 MYx_ATF_CHECK_EQ((uint32_t)hid_parse_usage_in_page("0xff2a:0xff1b"),
108 ATF_TC_HEAD(check_hid_logical_range, tc)
111 atf_tc_set_md_var(tc, "descr", "Test hid_get_item "
112 "Logical Minimum/Maximum results");
115 ATF_TC_BODY(check_hid_logical_range, tc)
119 uint32_t minimum, maximum;
121 atf_tc_expect_fail("only the 32-bit opcode works, "
122 "8 and 16-bit is broken");
124 ATF_REQUIRE((hrd = hid_use_report_desc(range_test_report_descriptor,
125 __arraycount(range_test_report_descriptor))) != NULL);
126 ATF_REQUIRE(hid_locate(hrd, 0xff000001U, hid_input, &hi,
128 MYd_ATF_CHECK_EQ(hi.logical_minimum, -128);
129 MYd_ATF_CHECK_EQ(hi.logical_maximum, 127);
130 ATF_REQUIRE(hid_locate(hrd, 0xff000002U, hid_input, &hi,
132 MYd_ATF_CHECK_EQ(hi.logical_minimum, -32768);
133 MYd_ATF_CHECK_EQ(hi.logical_maximum, 32767);
134 ATF_REQUIRE(hid_locate(hrd, 0xff000003U, hid_input, &hi,
136 MYd_ATF_CHECK_EQ(hi.logical_minimum, -2147483648);
137 MYd_ATF_CHECK_EQ(hi.logical_maximum, 2147483647);
139 hid_dispose_report_desc(hrd);
142 ATF_REQUIRE((hrd = hid_use_report_desc(
143 unsigned_range_test_report_descriptor,
144 __arraycount(unsigned_range_test_report_descriptor))) != NULL);
145 ATF_REQUIRE(hid_locate(hrd, 0xff000011U, hid_input, &hi,
147 ATF_CHECK(hi.logical_minimum > hi.logical_maximum);
148 minimum = (uint32_t)hi.logical_minimum & ((1ULL<<hi.report_size)-1);
149 MYu_ATF_CHECK_EQ(minimum, 0);
150 maximum = (uint32_t)hi.logical_maximum & ((1ULL<<hi.report_size)-1);
151 MYu_ATF_CHECK_EQ(maximum, 255);
152 ATF_REQUIRE(hid_locate(hrd, 0xff000012U, hid_input, &hi,
154 ATF_CHECK(hi.logical_minimum > hi.logical_maximum);
155 minimum = hi.logical_minimum & ((1ULL<<hi.report_size)-1);
156 MYu_ATF_CHECK_EQ(minimum, 0);
157 maximum = hi.logical_maximum & ((1ULL<<hi.report_size)-1);
158 MYu_ATF_CHECK_EQ(maximum, 65535);
159 ATF_REQUIRE(hid_locate(hrd, 0xff000013U, hid_input, &hi,
161 ATF_CHECK(hi.logical_minimum > hi.logical_maximum);
162 minimum = hi.logical_minimum & ((1ULL<<hi.report_size)-1);
163 MYu_ATF_CHECK_EQ(minimum, 0);
164 maximum = hi.logical_maximum & ((1ULL<<hi.report_size)-1);
165 MYu_ATF_CHECK_EQ(maximum, 4294967295);
167 hid_dispose_report_desc(hrd);
171 ATF_TC_HEAD(check_hid_physical_range, tc)
174 atf_tc_set_md_var(tc, "descr", "Test hid_get_item "
175 "Physical Minimum/Maximum results");
178 ATF_TC_BODY(check_hid_physical_range, tc)
182 uint32_t minimum, maximum;
184 atf_tc_expect_fail("only the 32-bit opcode works, "
185 "8 and 16-bit is broken");
187 ATF_REQUIRE((hrd = hid_use_report_desc(range_test_report_descriptor,
188 __arraycount(range_test_report_descriptor))) != NULL);
189 ATF_REQUIRE(hid_locate(hrd, 0xff000001U, hid_input, &hi,
191 MYd_ATF_CHECK_EQ(hi.physical_minimum, -128);
192 MYd_ATF_CHECK_EQ(hi.physical_maximum, 127);
193 ATF_REQUIRE(hid_locate(hrd, 0xff000002U, hid_input, &hi,
195 MYd_ATF_CHECK_EQ(hi.physical_minimum, -32768);
196 MYd_ATF_CHECK_EQ(hi.physical_maximum, 32767);
197 ATF_REQUIRE(hid_locate(hrd, 0xff000003U, hid_input, &hi,
199 MYd_ATF_CHECK_EQ(hi.physical_minimum, -2147483648);
200 MYd_ATF_CHECK_EQ(hi.physical_maximum, 2147483647);
202 hid_dispose_report_desc(hrd);
205 ATF_REQUIRE((hrd = hid_use_report_desc(
206 unsigned_range_test_report_descriptor,
207 __arraycount(unsigned_range_test_report_descriptor))) != NULL);
208 ATF_REQUIRE(hid_locate(hrd, 0xff000011U, hid_input, &hi,
210 ATF_CHECK(hi.physical_minimum > hi.physical_maximum);
211 minimum = (uint32_t)hi.physical_minimum & ((1ULL<<hi.report_size)-1);
212 MYu_ATF_CHECK_EQ(minimum, 0);
213 maximum = (uint32_t)hi.physical_maximum & ((1ULL<<hi.report_size)-1);
214 MYu_ATF_CHECK_EQ(maximum, 255);
215 ATF_REQUIRE(hid_locate(hrd, 0xff000012U, hid_input, &hi,
217 ATF_CHECK(hi.physical_minimum > hi.physical_maximum);
218 minimum = hi.physical_minimum & ((1ULL<<hi.report_size)-1);
219 MYu_ATF_CHECK_EQ(minimum, 0);
220 maximum = hi.physical_maximum & ((1ULL<<hi.report_size)-1);
221 MYu_ATF_CHECK_EQ(maximum, 65535);
222 ATF_REQUIRE(hid_locate(hrd, 0xff000013U, hid_input, &hi,
224 ATF_CHECK(hi.physical_minimum > hi.physical_maximum);
225 minimum = hi.physical_minimum & ((1ULL<<hi.report_size)-1);
226 MYu_ATF_CHECK_EQ(minimum, 0);
227 maximum = hi.physical_maximum & ((1ULL<<hi.report_size)-1);
228 MYu_ATF_CHECK_EQ(maximum, 4294967295);
230 hid_dispose_report_desc(hrd);
234 ATF_TC_HEAD(check_hid_get_data, tc)
237 atf_tc_set_md_var(tc, "descr", "Test hid_get_data results");
240 ATF_TC_BODY(check_hid_get_data, tc)
247 atf_tc_expect_fail("only the 32-bit opcode works, "
248 "8 and 16-bit is broken");
250 ATF_REQUIRE((hrd = hid_use_report_desc(
251 range_test_report_descriptor,
252 __arraycount(range_test_report_descriptor))) != NULL);
254 ATF_REQUIRE(hid_locate(hrd, 0xff000001U, hid_input, &hi,
256 data = hid_get_data(range_test_minimum_report, &hi);
257 MYd_ATF_CHECK_EQ(data, -128);
258 data = hid_get_data(range_test_negative_one_report, &hi);
259 MYd_ATF_CHECK_EQ(data, -1);
260 data = hid_get_data(range_test_positive_one_report, &hi);
261 MYd_ATF_CHECK_EQ(data, 1);
262 data = hid_get_data(range_test_maximum_report, &hi);
263 MYd_ATF_CHECK_EQ(data, 127);
265 ATF_REQUIRE(hid_locate(hrd, 0xff000002U, hid_input, &hi,
267 data = hid_get_data(range_test_minimum_report, &hi);
268 MYd_ATF_CHECK_EQ(data, -32768);
269 data = hid_get_data(range_test_negative_one_report, &hi);
270 MYd_ATF_CHECK_EQ(data, -1);
271 data = hid_get_data(range_test_positive_one_report, &hi);
272 MYd_ATF_CHECK_EQ(data, 1);
273 data = hid_get_data(range_test_maximum_report, &hi);
274 MYd_ATF_CHECK_EQ(data, 32767);
276 ATF_REQUIRE(hid_locate(hrd, 0xff000003U, hid_input, &hi,
278 data = hid_get_data(range_test_minimum_report, &hi);
279 MYd_ATF_CHECK_EQ(data, -2147483648);
280 data = hid_get_data(range_test_negative_one_report, &hi);
281 MYd_ATF_CHECK_EQ(data, -1);
282 data = hid_get_data(range_test_positive_one_report, &hi);
283 MYd_ATF_CHECK_EQ(data, 1);
284 data = hid_get_data(range_test_maximum_report, &hi);
285 MYd_ATF_CHECK_EQ(data, 2147483647);
287 hid_dispose_report_desc(hrd);
290 ATF_REQUIRE((hrd = hid_use_report_desc(
291 unsigned_range_test_report_descriptor,
292 __arraycount(unsigned_range_test_report_descriptor))) != NULL);
293 ATF_REQUIRE(hid_locate(hrd, 0xff000011U, hid_input, &hi,
295 udat = hid_get_data(unsigned_range_test_minimum_report, &hi);
296 MYu_ATF_CHECK_EQ(udat, 0);
297 udat = hid_get_data(unsigned_range_test_positive_one_report, &hi);
298 MYu_ATF_CHECK_EQ(udat, 1);
299 udat = hid_get_data(unsigned_range_test_negative_one_report, &hi);
300 MYu_ATF_CHECK_EQ(udat, 254);
301 udat = hid_get_data(unsigned_range_test_maximum_report, &hi);
302 MYu_ATF_CHECK_EQ(udat, 255);
304 ATF_REQUIRE(hid_locate(hrd, 0xff000012U, hid_input, &hi,
306 udat = hid_get_data(unsigned_range_test_minimum_report, &hi);
307 MYu_ATF_CHECK_EQ(udat, 0);
308 udat = hid_get_data(unsigned_range_test_positive_one_report, &hi);
309 MYu_ATF_CHECK_EQ(udat, 1);
310 udat = hid_get_data(unsigned_range_test_negative_one_report, &hi);
311 MYu_ATF_CHECK_EQ(udat, 65534);
312 udat = hid_get_data(unsigned_range_test_maximum_report, &hi);
313 MYu_ATF_CHECK_EQ(udat, 65535);
315 ATF_REQUIRE(hid_locate(hrd, 0xff000013U, hid_input, &hi,
317 udat = hid_get_data(unsigned_range_test_minimum_report, &hi);
318 MYu_ATF_CHECK_EQ(udat, 0);
319 udat = hid_get_data(unsigned_range_test_positive_one_report, &hi);
320 MYu_ATF_CHECK_EQ(udat, 1);
321 udat = hid_get_data(unsigned_range_test_negative_one_report, &hi);
322 MYu_ATF_CHECK_EQ(udat, 4294967294);
323 udat = hid_get_data(unsigned_range_test_maximum_report, &hi);
324 MYu_ATF_CHECK_EQ(udat, 4294967295);
326 hid_dispose_report_desc(hrd);
330 ATF_TC_HEAD(check_hid_set_data, tc)
333 atf_tc_set_md_var(tc, "descr", "Test hid_set_data results");
336 ATF_TC_BODY(check_hid_set_data, tc)
340 uint8_t test_data_minimum[7];
341 uint8_t test_data_negative_one[7];
342 uint8_t test_data_positive_one[7];
343 uint8_t test_data_maximum[7];
345 ATF_REQUIRE((hrd = hid_use_report_desc(
346 range_test_report_descriptor,
347 __arraycount(range_test_report_descriptor))) != NULL);
348 ATF_REQUIRE(hid_locate(hrd, 0xff000001U, hid_input, &hi,
350 hid_set_data(test_data_minimum, &hi, -128);
351 hid_set_data(test_data_negative_one, &hi, -1);
352 hid_set_data(test_data_positive_one, &hi, 1);
353 hid_set_data(test_data_maximum, &hi, 127);
354 ATF_REQUIRE(hid_locate(hrd, 0xff000002U, hid_input, &hi,
356 hid_set_data(test_data_minimum, &hi, -32768);
357 hid_set_data(test_data_negative_one, &hi, -1);
358 hid_set_data(test_data_positive_one, &hi, 1);
359 hid_set_data(test_data_maximum, &hi, 32767);
360 ATF_REQUIRE(hid_locate(hrd, 0xff000003U, hid_input, &hi,
362 hid_set_data(test_data_minimum, &hi, -2147483648);
363 hid_set_data(test_data_negative_one, &hi, -1);
364 hid_set_data(test_data_positive_one, &hi, 1);
365 hid_set_data(test_data_maximum, &hi, 2147483647);
366 ATF_CHECK(memcmp(test_data_minimum, range_test_minimum_report,
367 sizeof test_data_minimum) == 0);
368 ATF_CHECK(memcmp(test_data_negative_one,
369 range_test_negative_one_report,
370 sizeof test_data_negative_one) == 0);
371 ATF_CHECK(memcmp(test_data_positive_one,
372 range_test_positive_one_report,
373 sizeof test_data_positive_one) == 0);
374 ATF_CHECK(memcmp(test_data_maximum, range_test_maximum_report,
375 sizeof test_data_maximum) == 0);
377 hid_dispose_report_desc(hrd);
380 ATF_REQUIRE((hrd = hid_use_report_desc(
381 unsigned_range_test_report_descriptor,
382 __arraycount(range_test_report_descriptor))) != NULL);
383 ATF_REQUIRE(hid_locate(hrd, 0xff000011U, hid_input, &hi,
385 hid_set_data(test_data_minimum, &hi, 0);
386 hid_set_data(test_data_positive_one, &hi, 1);
387 hid_set_data(test_data_negative_one, &hi, 0xfffffffe);
388 hid_set_data(test_data_maximum, &hi, 0xffffffff);
389 ATF_REQUIRE(hid_locate(hrd, 0xff000012U, hid_input, &hi,
391 hid_set_data(test_data_minimum, &hi, 0);
392 hid_set_data(test_data_positive_one, &hi, 1);
393 hid_set_data(test_data_negative_one, &hi, 0xfffe);
394 hid_set_data(test_data_maximum, &hi, 0xffff);
395 ATF_REQUIRE(hid_locate(hrd, 0xff000013U, hid_input, &hi,
397 hid_set_data(test_data_minimum, &hi, 0);
398 hid_set_data(test_data_positive_one, &hi, 1);
399 hid_set_data(test_data_negative_one, &hi, 0xfffffffe);
400 hid_set_data(test_data_maximum, &hi, 0xffffffff);
401 ATF_CHECK(memcmp(test_data_minimum,
402 unsigned_range_test_minimum_report,
403 sizeof test_data_minimum) == 0);
404 ATF_CHECK(memcmp(test_data_negative_one,
405 unsigned_range_test_negative_one_report,
406 sizeof test_data_negative_one) == 0);
407 ATF_CHECK(memcmp(test_data_positive_one,
408 unsigned_range_test_positive_one_report,
409 sizeof test_data_positive_one) == 0);
410 ATF_CHECK(memcmp(test_data_maximum,
411 unsigned_range_test_maximum_report,
412 sizeof test_data_maximum) == 0);
414 hid_dispose_report_desc(hrd);
418 ATF_TC_HEAD(check_parse_just_pop, tc)
421 atf_tc_set_md_var(tc, "descr", "check Pop on empty stack bug");
424 ATF_TC_BODY(check_parse_just_pop, tc)
430 ATF_REQUIRE((hrd = hid_use_report_desc(
431 just_pop_report_descriptor,
432 sizeof just_pop_report_descriptor)) != NULL);
433 hd = hid_start_parse(hrd, 0, NO_REPORT_ID);
434 while (hid_get_item(hd, &hi) > 0) {
437 hid_dispose_report_desc(hrd);
444 ATF_TP_ADD_TC(tp, check_hid_logical_range);
445 ATF_TP_ADD_TC(tp, check_hid_physical_range);
446 ATF_TP_ADD_TC(tp, check_hid_usage);
447 ATF_TP_ADD_TC(tp, check_hid_get_data);
448 ATF_TP_ADD_TC(tp, check_hid_set_data);
449 ATF_TP_ADD_TC(tp, check_parse_just_pop);
451 return atf_no_error();