2 * Copyright (c) 2016 Adam Starak <starak.adam@gmail.com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
34 #include <sys/types.h>
36 #include <atf-c++.hpp>
40 #define fd_is_valid(fd) (fcntl((fd), F_GETFL) != -1 || errno != EBADF)
42 /* ATF cnvlist_get tests. */
44 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_bool);
45 ATF_TEST_CASE_BODY(cnvlist_get_bool)
53 nvl = nvlist_create(0);
54 ATF_REQUIRE(nvl != NULL);
55 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
56 ATF_REQUIRE(nvlist_empty(nvl));
62 nvlist_add_bool(nvl, key, value);
63 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
64 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
65 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
66 ATF_REQUIRE(!nvlist_empty(nvl));
67 ATF_REQUIRE(nvlist_exists(nvl, key));
68 ATF_REQUIRE(nvlist_exists_bool(nvl, key));
70 ATF_REQUIRE_EQ(cnvlist_get_bool(cookie), value);
72 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
73 static_cast<const char *>(NULL));
78 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_number);
79 ATF_TEST_CASE_BODY(cnvlist_get_number)
87 nvl = nvlist_create(0);
88 ATF_REQUIRE(nvl != NULL);
89 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
90 ATF_REQUIRE(nvlist_empty(nvl));
96 nvlist_add_number(nvl, key, value);
97 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
98 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
99 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
100 ATF_REQUIRE(!nvlist_empty(nvl));
101 ATF_REQUIRE(nvlist_exists(nvl, key));
102 ATF_REQUIRE(nvlist_exists_number(nvl, key));
104 ATF_REQUIRE_EQ(cnvlist_get_number(cookie), value);
106 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
107 static_cast<const char *>(NULL));
113 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_string);
114 ATF_TEST_CASE_BODY(cnvlist_get_string)
122 nvl = nvlist_create(0);
123 ATF_REQUIRE(nvl != NULL);
124 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
125 ATF_REQUIRE(nvlist_empty(nvl));
131 nvlist_add_string(nvl, key, value);
132 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
133 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
134 ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
135 ATF_REQUIRE(!nvlist_empty(nvl));
136 ATF_REQUIRE(nvlist_exists(nvl, key));
137 ATF_REQUIRE(nvlist_exists_string(nvl, key));
139 ATF_REQUIRE_EQ(strcmp(cnvlist_get_string(cookie), value), 0);
141 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
142 static_cast<const char *>(NULL));
147 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_nvlist);
148 ATF_TEST_CASE_BODY(cnvlist_get_nvlist)
150 nvlist_t *nvl, *value;
151 const nvlist_t *result;
152 const char *key, *subkey;
156 nvl = nvlist_create(0);
157 ATF_REQUIRE(nvl != NULL);
158 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
159 ATF_REQUIRE(nvlist_empty(nvl));
161 value = nvlist_create(0);
162 ATF_REQUIRE(nvl != NULL);
163 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
164 ATF_REQUIRE(nvlist_empty(nvl));
170 /* Add null to 'value' nvlist. */
171 nvlist_add_null(value, subkey);
172 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(value, &type, &cookie)), 0);
173 ATF_REQUIRE_EQ(nvlist_error(value), 0);
174 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
175 ATF_REQUIRE(!nvlist_empty(value));
176 ATF_REQUIRE(nvlist_exists(value, subkey));
177 ATF_REQUIRE(nvlist_exists_null(value, subkey));
178 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie),
179 static_cast<const char *>(NULL));
181 /* Add 'value' nvlist. */
183 nvlist_add_nvlist(nvl, key, value);
184 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
185 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
186 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
187 ATF_REQUIRE(!nvlist_empty(nvl));
188 ATF_REQUIRE(nvlist_exists(nvl, key));
189 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
192 * Assuming nvlist_get_nvlist() is correct check if cnvlist returns
195 result = cnvlist_get_nvlist(cookie);
196 ATF_REQUIRE_EQ(result, nvlist_get_nvlist(nvl, key));
197 ATF_REQUIRE(result != value);
198 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
199 static_cast<const char *>(NULL));
201 /* Validate data inside nvlist. */
203 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(result, &type, &cookie)), 0);
204 ATF_REQUIRE_EQ(nvlist_error(result), 0);
205 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
206 ATF_REQUIRE(!nvlist_empty(result));
207 ATF_REQUIRE(nvlist_exists(result, subkey));
208 ATF_REQUIRE(nvlist_exists_null(result, subkey));
209 ATF_REQUIRE_EQ(nvlist_next(result, &type, &cookie),
210 static_cast<const char *>(NULL));
213 nvlist_destroy(value);
216 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_descriptor);
217 ATF_TEST_CASE_BODY(cnvlist_get_descriptor)
224 nvl = nvlist_create(0);
225 ATF_REQUIRE(nvl != NULL);
226 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
227 ATF_REQUIRE(nvlist_empty(nvl));
232 nvlist_add_descriptor(nvl, key, STDERR_FILENO);
233 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
234 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
235 ATF_REQUIRE_EQ(type, NV_TYPE_DESCRIPTOR);
236 ATF_REQUIRE(!nvlist_empty(nvl));
237 ATF_REQUIRE(nvlist_exists(nvl, key));
238 ATF_REQUIRE(nvlist_exists_descriptor(nvl, key));
240 ATF_REQUIRE_EQ(fd_is_valid(cnvlist_get_descriptor(cookie)), 1);
242 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
243 static_cast<const char *>(NULL));
248 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_binary);
249 ATF_TEST_CASE_BODY(cnvlist_get_binary)
254 const void *out_binary;
257 size_t in_size, out_size;
259 nvl = nvlist_create(0);
260 ATF_REQUIRE(nvl != NULL);
261 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
262 ATF_REQUIRE(nvlist_empty(nvl));
268 in_binary = malloc(in_size);
269 ATF_REQUIRE(in_binary != NULL);
270 memset(in_binary, 0xa5, in_size);
272 nvlist_add_binary(nvl, key, in_binary, in_size);
273 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
274 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
275 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
276 ATF_REQUIRE(!nvlist_empty(nvl));
277 ATF_REQUIRE(nvlist_exists(nvl, key));
278 ATF_REQUIRE(nvlist_exists_binary(nvl, key));
280 out_binary = cnvlist_get_binary(cookie, &out_size);
281 ATF_REQUIRE_EQ(out_size, in_size);
282 ATF_REQUIRE_EQ(memcmp(in_binary, out_binary, out_size), 0);
284 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
285 static_cast<const char *>(NULL));
290 /* ATF cnvlist_get array tests. */
292 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_bool_array);
293 ATF_TEST_CASE_BODY(cnvlist_get_bool_array)
297 const bool *out_array;
303 for (i = 0; i < 16; i++)
304 in_array[i] = (i % 2 == 0);
306 nvl = nvlist_create(0);
307 ATF_REQUIRE(nvl != NULL);
308 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
309 ATF_REQUIRE(nvlist_empty(nvl));
314 nvlist_add_bool_array(nvl, key, in_array, 16);
315 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
316 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
317 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL_ARRAY);
318 ATF_REQUIRE(!nvlist_empty(nvl));
319 ATF_REQUIRE(nvlist_exists(nvl, key));
320 ATF_REQUIRE(nvlist_exists_bool_array(nvl, key));
322 out_array = cnvlist_get_bool_array(cookie, &nitems);
323 ATF_REQUIRE_EQ(nitems, 16);
324 ATF_REQUIRE(out_array != NULL);
325 for (i = 0; i < 16; i++)
326 ATF_REQUIRE_EQ(out_array[i], in_array[i]);
328 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
329 static_cast<const char *>(NULL));
334 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_number_array);
335 ATF_TEST_CASE_BODY(cnvlist_get_number_array)
338 uint64_t in_array[16];
339 const uint64_t *out_array;
345 for (i = 0; i < 16; i++)
348 nvl = nvlist_create(0);
349 ATF_REQUIRE(nvl != NULL);
350 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
351 ATF_REQUIRE(nvlist_empty(nvl));
356 nvlist_add_number_array(nvl, key, in_array, 16);
357 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
358 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
359 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER_ARRAY);
360 ATF_REQUIRE(!nvlist_empty(nvl));
361 ATF_REQUIRE(nvlist_exists(nvl, key));
362 ATF_REQUIRE(nvlist_exists_number_array(nvl, key));
364 out_array = cnvlist_get_number_array(cookie, &nitems);
365 ATF_REQUIRE(out_array != NULL);
366 ATF_REQUIRE_EQ(nitems, 16);
367 for (i = 0; i < 16; i++)
368 ATF_REQUIRE_EQ(out_array[i], in_array[i]);
370 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
371 static_cast<const char *>(NULL));
376 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_string_array);
377 ATF_TEST_CASE_BODY(cnvlist_get_string_array)
380 const char *in_array[4] = {"inequality", "sucks", ".", ""};
381 const char * const *out_array;
387 nvl = nvlist_create(0);
388 ATF_REQUIRE(nvl != NULL);
389 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
390 ATF_REQUIRE(nvlist_empty(nvl));
395 nvlist_add_string_array(nvl, key, in_array, 4);
396 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
397 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
398 ATF_REQUIRE_EQ(type, NV_TYPE_STRING_ARRAY);
399 ATF_REQUIRE(!nvlist_empty(nvl));
400 ATF_REQUIRE(nvlist_exists(nvl, key));
401 ATF_REQUIRE(nvlist_exists_string_array(nvl, key));
403 out_array = cnvlist_get_string_array(cookie, &nitems);
404 ATF_REQUIRE_EQ(nitems, 4);
405 ATF_REQUIRE(out_array != NULL);
406 for (i = 0; i < 4; i++) {
407 ATF_REQUIRE(out_array[i] != NULL);
408 ATF_REQUIRE_EQ(strcmp(out_array[i], in_array[i]), 0);
411 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
412 static_cast<const char *>(NULL));
417 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_nvlist_array);
418 ATF_TEST_CASE_BODY(cnvlist_get_nvlist_array)
421 nvlist_t *in_array[6];
422 const nvlist_t * const *out_array;
423 const nvlist_t * const *out_result;
430 nvl = nvlist_create(0);
431 ATF_REQUIRE(nvl != NULL);
432 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
433 ATF_REQUIRE(nvlist_empty(nvl));
436 for (i = 0; i < 6; i++) {
437 in_array[i] = nvlist_create(0);
438 ATF_REQUIRE(in_array[i] != NULL);
439 ATF_REQUIRE_EQ(nvlist_error(in_array[i]), 0);
440 ATF_REQUIRE(nvlist_empty(in_array[i]));
444 nvlist_add_null(in_array[i], subkeys+i);
445 ATF_REQUIRE_EQ(strcmp(subkeys+i, nvlist_next(in_array[i],
447 ATF_REQUIRE_EQ(nvlist_error(in_array[i]), 0);
448 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
449 ATF_REQUIRE(!nvlist_empty(in_array[i]));
450 ATF_REQUIRE(nvlist_exists(in_array[i], subkeys+i));
451 ATF_REQUIRE(nvlist_exists_null(in_array[i], subkeys+i));
452 ATF_REQUIRE_EQ(nvlist_next(in_array[i], &type, &cookie),
453 static_cast<const char *>(NULL));
459 nvlist_add_nvlist_array(nvl, key, in_array, 6);
460 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
461 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
462 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST_ARRAY);
463 ATF_REQUIRE(!nvlist_empty(nvl));
464 ATF_REQUIRE(nvlist_exists(nvl, key));
465 ATF_REQUIRE(nvlist_exists_nvlist_array(nvl, key));
467 /* Get nvlist array by cnvlist function. */
468 out_array = cnvlist_get_nvlist_array(cookie, &nitems);
469 ATF_REQUIRE(out_array != NULL);
470 ATF_REQUIRE_EQ(nitems, 6);
471 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
472 static_cast<const char *>(NULL));
474 /* Get nvlist array by nvlist function. */
475 out_result = nvlist_get_nvlist_array(nvl, key, &nitems);
476 ATF_REQUIRE(out_result != NULL);
477 ATF_REQUIRE_EQ(nitems, 6);
479 /* Validate assuming that nvlist returned a proper pointer */
480 for (i = 0; i < 6; i++) {
481 ATF_REQUIRE_EQ(out_result[i], out_array[i]);
482 ATF_REQUIRE(out_array[i] != in_array[i]);
484 /* Validate data inside nvlist. */
486 ATF_REQUIRE_EQ(strcmp(subkeys+i, nvlist_next(out_array[i],
487 &type, &cookie)), 0);
488 ATF_REQUIRE_EQ(nvlist_error(out_array[i]), 0);
489 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
490 ATF_REQUIRE(!nvlist_empty(out_array[i]));
491 ATF_REQUIRE(nvlist_exists(out_array[i], subkeys+i));
492 ATF_REQUIRE(nvlist_exists_null(out_array[i], subkeys+i));
493 ATF_REQUIRE_EQ(nvlist_next(out_array[i], &type, &cookie),
494 static_cast<const char *>(NULL));
500 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_get_descriptor_array);
501 ATF_TEST_CASE_BODY(cnvlist_get_descriptor_array)
504 size_t count, i, nitems;
505 const int *out_array;
510 nvl = nvlist_create(0);
511 ATF_REQUIRE(nvl != NULL);
512 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
513 ATF_REQUIRE(nvlist_empty(nvl));
519 in_array = static_cast<int *>(malloc(sizeof(*in_array)*count));
520 ATF_REQUIRE(in_array != NULL);
521 for (i = 0; i < count; i++) {
522 in_array[i] = dup(STDERR_FILENO);
523 ATF_REQUIRE(fd_is_valid(in_array[i]));
526 nvlist_add_descriptor_array(nvl, key, in_array, count);
527 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
528 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
529 ATF_REQUIRE_EQ(type, NV_TYPE_DESCRIPTOR_ARRAY);
530 ATF_REQUIRE(!nvlist_empty(nvl));
531 ATF_REQUIRE(nvlist_exists(nvl, key));
532 ATF_REQUIRE(nvlist_exists_descriptor_array(nvl, key));
534 out_array = cnvlist_get_descriptor_array(cookie, &nitems);
535 ATF_REQUIRE_EQ(nitems, count);
536 ATF_REQUIRE(out_array != NULL);
537 for (i = 0; i < count; i++)
538 ATF_REQUIRE_EQ(fd_is_valid(out_array[i]), 1);
540 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
541 static_cast<const char *>(NULL));
546 /* ATF cnvlist_take tests. */
548 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_bool);
549 ATF_TEST_CASE_BODY(cnvlist_take_bool)
557 nvl = nvlist_create(0);
558 ATF_REQUIRE(nvl != NULL);
559 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
560 ATF_REQUIRE(nvlist_empty(nvl));
566 nvlist_add_bool(nvl, key, value);
567 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
568 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
569 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
570 ATF_REQUIRE(!nvlist_empty(nvl));
571 ATF_REQUIRE(nvlist_exists(nvl, key));
572 ATF_REQUIRE(nvlist_exists_bool(nvl, key));
573 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
574 static_cast<const char *>(NULL));
577 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
578 ATF_REQUIRE_EQ(cnvlist_take_bool(nvl, cookie), value);
581 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
582 ATF_REQUIRE(nvlist_empty(nvl));
583 ATF_REQUIRE(!nvlist_exists(nvl, key));
584 ATF_REQUIRE(!nvlist_exists_bool(nvl, key));
585 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
586 static_cast<const char *>(NULL));
591 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_number);
592 ATF_TEST_CASE_BODY(cnvlist_take_number)
600 nvl = nvlist_create(0);
601 ATF_REQUIRE(nvl != NULL);
602 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
603 ATF_REQUIRE(nvlist_empty(nvl));
609 nvlist_add_number(nvl, key, value);
610 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
611 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
612 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
613 ATF_REQUIRE(!nvlist_empty(nvl));
614 ATF_REQUIRE(nvlist_exists(nvl, key));
615 ATF_REQUIRE(nvlist_exists_number(nvl, key));
616 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
617 static_cast<const char *>(NULL));
620 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
621 ATF_REQUIRE_EQ(cnvlist_take_number(nvl, cookie), value);
624 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
625 ATF_REQUIRE(nvlist_empty(nvl));
626 ATF_REQUIRE(!nvlist_exists(nvl, key));
627 ATF_REQUIRE(!nvlist_exists_number(nvl, key));
628 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
629 static_cast<const char *>(NULL));
634 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_string);
635 ATF_TEST_CASE_BODY(cnvlist_take_string)
644 nvl = nvlist_create(0);
645 ATF_REQUIRE(nvl != NULL);
646 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
647 ATF_REQUIRE(nvlist_empty(nvl));
653 nvlist_add_string(nvl, key, value);
654 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
655 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
656 ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
657 ATF_REQUIRE(!nvlist_empty(nvl));
658 ATF_REQUIRE(nvlist_exists(nvl, key));
659 ATF_REQUIRE(nvlist_exists_string(nvl, key));
660 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
661 static_cast<const char *>(NULL));
664 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
665 out_string = cnvlist_take_string(nvl, cookie);
666 ATF_REQUIRE(out_string != NULL);
667 ATF_REQUIRE_EQ(strcmp(out_string, value), 0);
670 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
671 ATF_REQUIRE(nvlist_empty(nvl));
672 ATF_REQUIRE(!nvlist_exists(nvl, key));
673 ATF_REQUIRE(!nvlist_exists_string(nvl, key));
674 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
675 static_cast<const char *>(NULL));
681 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_nvlist);
682 ATF_TEST_CASE_BODY(cnvlist_take_nvlist)
684 nvlist_t *nvl, *value, *result;
685 const char *key, *subkey;
689 nvl = nvlist_create(0);
690 ATF_REQUIRE(nvl != NULL);
691 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
692 ATF_REQUIRE(nvlist_empty(nvl));
694 value = nvlist_create(0);
695 ATF_REQUIRE(value != NULL);
696 ATF_REQUIRE_EQ(nvlist_error(value), 0);
697 ATF_REQUIRE(nvlist_empty(value));
703 /* Add null to 'value' nvlist. */
704 nvlist_add_null(value, subkey);
705 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(value, &type, &cookie)), 0);
706 ATF_REQUIRE_EQ(nvlist_error(value), 0);
707 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
708 ATF_REQUIRE(!nvlist_empty(value));
709 ATF_REQUIRE(nvlist_exists(value, subkey));
710 ATF_REQUIRE(nvlist_exists_null(value, subkey));
711 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie),
712 static_cast<const char *>(NULL));
714 /* Add 'value' nvlist. */
716 nvlist_move_nvlist(nvl, key, value);
717 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
718 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
719 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
720 ATF_REQUIRE(!nvlist_empty(nvl));
721 ATF_REQUIRE(nvlist_exists(nvl, key));
722 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
723 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
724 static_cast<const char *>(NULL));
727 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
728 result = cnvlist_take_nvlist(nvl, cookie);
729 ATF_REQUIRE(!nvlist_exists_nvlist(nvl, key));
730 ATF_REQUIRE(result == value);
732 /* Validate data inside nvlist. */
734 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(result, &type, &cookie)), 0);
735 ATF_REQUIRE_EQ(nvlist_error(value), 0);
736 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
737 ATF_REQUIRE(!nvlist_empty(value));
738 ATF_REQUIRE(nvlist_exists(value, subkey));
739 ATF_REQUIRE(nvlist_exists_null(value, subkey));
740 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie),
741 static_cast<const char *>(NULL));
744 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
745 static_cast<const char *>(NULL));
748 nvlist_destroy(value);
751 /* ATF cnvlist_take array tests */
753 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_bool_array);
754 ATF_TEST_CASE_BODY(cnvlist_take_bool_array)
758 const bool *out_array;
764 for (i = 0; i < 16; i++)
765 in_array[i] = (i % 2 == 0);
767 nvl = nvlist_create(0);
768 ATF_REQUIRE(nvl != NULL);
769 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
770 ATF_REQUIRE(nvlist_empty(nvl));
775 nvlist_add_bool_array(nvl, key, in_array, 16);
776 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
777 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
778 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL_ARRAY);
779 ATF_REQUIRE(!nvlist_empty(nvl));
780 ATF_REQUIRE(nvlist_exists(nvl, key));
781 ATF_REQUIRE(nvlist_exists_bool_array(nvl, key));
782 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
783 static_cast<const char *>(NULL));
786 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
787 out_array = cnvlist_take_bool_array(nvl, cookie, &nitems);
788 ATF_REQUIRE_EQ(nitems, 16);
789 ATF_REQUIRE(out_array != NULL);
790 for (i = 0; i < 16; i++)
791 ATF_REQUIRE_EQ(out_array[i], in_array[i]);
794 ATF_REQUIRE(!nvlist_exists_bool_array(nvl, key));
795 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
796 ATF_REQUIRE(nvlist_empty(nvl));
797 ATF_REQUIRE(!nvlist_exists(nvl, key));
798 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
799 static_cast<const char *>(NULL));
805 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_number_array);
806 ATF_TEST_CASE_BODY(cnvlist_take_number_array)
809 uint64_t in_array[16];
810 const uint64_t *out_array;
816 for (i = 0; i < 16; i++)
819 nvl = nvlist_create(0);
820 ATF_REQUIRE(nvl != NULL);
821 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
822 ATF_REQUIRE(nvlist_empty(nvl));
827 nvlist_add_number_array(nvl, key, in_array, 16);
828 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
829 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
830 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER_ARRAY);
831 ATF_REQUIRE(!nvlist_empty(nvl));
832 ATF_REQUIRE(nvlist_exists(nvl, key));
833 ATF_REQUIRE(nvlist_exists_number_array(nvl, key));
834 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
835 static_cast<const char *>(NULL));
838 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
839 out_array = cnvlist_take_number_array(nvl, cookie, &nitems);
841 ATF_REQUIRE(out_array != NULL);
842 ATF_REQUIRE_EQ(nitems, 16);
843 for (i = 0; i < 16; i++)
844 ATF_REQUIRE_EQ(out_array[i], in_array[i]);
847 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
848 ATF_REQUIRE(nvlist_empty(nvl));
849 ATF_REQUIRE(!nvlist_exists(nvl, key));
850 ATF_REQUIRE(!nvlist_exists_number_array(nvl, key));
851 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
852 static_cast<const char *>(NULL));
857 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_string_array);
858 ATF_TEST_CASE_BODY(cnvlist_take_string_array)
861 const char *in_array[4] = {"inequality", "sks", ".", ""};
868 nvl = nvlist_create(0);
869 ATF_REQUIRE(nvl != NULL);
870 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
871 ATF_REQUIRE(nvlist_empty(nvl));
876 nvlist_add_string_array(nvl, key, in_array, 4);
877 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
878 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
879 ATF_REQUIRE_EQ(type, NV_TYPE_STRING_ARRAY);
880 ATF_REQUIRE(!nvlist_empty(nvl));
881 ATF_REQUIRE(nvlist_exists(nvl, key));
882 ATF_REQUIRE(nvlist_exists_string_array(nvl, key));
883 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
884 static_cast<const char *>(NULL));
887 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
888 out_array = cnvlist_take_string_array(nvl, cookie, &nitems);
889 ATF_REQUIRE_EQ(nitems, 4);
890 for (i = 0; i < 4; i++) {
891 ATF_REQUIRE(out_array[i] != NULL);
892 ATF_REQUIRE_EQ(strcmp(out_array[i], in_array[i]), 0);
894 ATF_REQUIRE(nvlist_empty(nvl));
897 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
898 ATF_REQUIRE(nvlist_empty(nvl));
899 ATF_REQUIRE(!nvlist_exists(nvl, key));
900 ATF_REQUIRE(!nvlist_exists_number_array(nvl, key));
901 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
902 static_cast<const char *>(NULL));
908 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_nvlist_array);
909 ATF_TEST_CASE_BODY(cnvlist_take_nvlist_array)
911 nvlist_t *testnvl[8];
918 const char *somestr[8] = { "a", "b", "c", "d", "e", "f", "g", "h" };
921 for (i = 0; i < 8; i++) {
922 testnvl[i] = nvlist_create(0);
923 ATF_REQUIRE(testnvl[i] != NULL);
924 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0);
925 ATF_REQUIRE(nvlist_empty(testnvl[i]));
926 nvlist_add_string(testnvl[i], "nvl/string", somestr[i]);
929 ATF_REQUIRE_EQ(strcmp("nvl/string", nvlist_next(testnvl[i],
930 &type, &cookie)), 0);
931 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0);
932 ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
933 ATF_REQUIRE(!nvlist_empty(testnvl[i]));
934 ATF_REQUIRE(nvlist_exists(testnvl[i], "nvl/string"));
935 ATF_REQUIRE(nvlist_exists_string(testnvl[i], "nvl/string"));
936 ATF_REQUIRE_EQ(nvlist_next(testnvl[i], &type, &cookie),
937 static_cast<const char *>(NULL));
940 nvl = nvlist_create(0);
941 ATF_REQUIRE(nvl != NULL);
942 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
943 ATF_REQUIRE(nvlist_empty(nvl));
948 nvlist_add_nvlist_array(nvl, key, (const nvlist_t * const *)testnvl, 8);
949 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
950 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
951 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST_ARRAY);
952 ATF_REQUIRE(!nvlist_empty(nvl));
953 ATF_REQUIRE(nvlist_exists(nvl, key));
954 ATF_REQUIRE(nvlist_exists_nvlist_array(nvl, key));
955 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
956 static_cast<const char *>(NULL));
959 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
960 result = cnvlist_take_nvlist_array(nvl, cookie, &num_items);
962 ATF_REQUIRE(result != NULL);
963 ATF_REQUIRE_EQ(num_items, 8);
964 for (i = 0; i < num_items; i++) {
965 ATF_REQUIRE_EQ(nvlist_error(result[i]), 0);
966 ATF_REQUIRE(nvlist_get_array_next(result[i]) == NULL);
969 ATF_REQUIRE(!nvlist_exists_string_array(nvl, key));
970 ATF_REQUIRE(nvlist_empty(nvl));
971 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
974 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
975 ATF_REQUIRE(nvlist_empty(nvl));
976 ATF_REQUIRE(!nvlist_exists(nvl, key));
977 ATF_REQUIRE(!nvlist_exists_nvlist_array(nvl, key));
978 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
979 static_cast<const char *>(NULL));
981 for (i = 0; i < 8; i++) {
982 nvlist_destroy(result[i]);
983 nvlist_destroy(testnvl[i]);
990 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_take_binary);
991 ATF_TEST_CASE_BODY(cnvlist_take_binary)
996 const void *out_binary;
999 size_t in_size, out_size;
1001 nvl = nvlist_create(0);
1002 ATF_REQUIRE(nvl != NULL);
1003 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1004 ATF_REQUIRE(nvlist_empty(nvl));
1009 in_binary = malloc(in_size);
1010 ATF_REQUIRE(in_binary != NULL);
1011 memset(in_binary, 0xa5, in_size);
1013 nvlist_add_binary(nvl, key, in_binary, in_size);
1014 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1015 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1016 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
1017 ATF_REQUIRE(!nvlist_empty(nvl));
1018 ATF_REQUIRE(nvlist_exists(nvl, key));
1019 ATF_REQUIRE(nvlist_exists_binary(nvl, key));
1020 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1021 static_cast<const char *>(NULL));
1024 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1025 out_binary = cnvlist_take_binary(nvl, cookie, &out_size);
1026 ATF_REQUIRE_EQ(out_size, in_size);
1027 ATF_REQUIRE_EQ(memcmp(in_binary, out_binary, out_size), 0);
1030 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1031 ATF_REQUIRE(nvlist_empty(nvl));
1032 ATF_REQUIRE(!nvlist_exists(nvl, key));
1033 ATF_REQUIRE(!nvlist_exists_binary(nvl, key));
1034 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1035 static_cast<const char *>(NULL));
1037 nvlist_destroy(nvl);
1040 /* ATF cnvlist_free tests. */
1042 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_bool);
1043 ATF_TEST_CASE_BODY(cnvlist_free_bool)
1051 nvl = nvlist_create(0);
1052 ATF_REQUIRE(nvl != NULL);
1053 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1054 ATF_REQUIRE(nvlist_empty(nvl));
1060 nvlist_add_bool(nvl, key, value);
1061 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1062 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1063 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
1064 ATF_REQUIRE(!nvlist_empty(nvl));
1065 ATF_REQUIRE(nvlist_exists(nvl, key));
1066 ATF_REQUIRE(nvlist_exists_bool(nvl, key));
1067 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1068 static_cast<const char *>(NULL));
1071 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1072 cnvlist_free_bool(nvl, cookie);
1075 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1076 ATF_REQUIRE(nvlist_empty(nvl));
1077 ATF_REQUIRE(!nvlist_exists(nvl, key));
1078 ATF_REQUIRE(!nvlist_exists_bool(nvl, key));
1079 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1080 static_cast<const char *>(NULL));
1082 nvlist_destroy(nvl);
1085 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_number);
1086 ATF_TEST_CASE_BODY(cnvlist_free_number)
1094 nvl = nvlist_create(0);
1095 ATF_REQUIRE(nvl != NULL);
1096 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1097 ATF_REQUIRE(nvlist_empty(nvl));
1103 nvlist_add_number(nvl, key, value);
1104 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1105 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1106 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
1107 ATF_REQUIRE(!nvlist_empty(nvl));
1108 ATF_REQUIRE(nvlist_exists(nvl, key));
1109 ATF_REQUIRE(nvlist_exists_number(nvl, key));
1110 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1111 static_cast<const char *>(NULL));
1114 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1115 cnvlist_free_number(nvl, cookie);
1118 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1119 ATF_REQUIRE(nvlist_empty(nvl));
1120 ATF_REQUIRE(!nvlist_exists(nvl, key));
1121 ATF_REQUIRE(!nvlist_exists_number(nvl, key));
1122 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1123 static_cast<const char *>(NULL));
1125 nvlist_destroy(nvl);
1128 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_string);
1129 ATF_TEST_CASE_BODY(cnvlist_free_string)
1137 nvl = nvlist_create(0);
1138 ATF_REQUIRE(nvl != NULL);
1139 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1140 ATF_REQUIRE(nvlist_empty(nvl));
1146 nvlist_add_string(nvl, key, value);
1147 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1148 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1149 ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
1150 ATF_REQUIRE(!nvlist_empty(nvl));
1151 ATF_REQUIRE(nvlist_exists(nvl, key));
1152 ATF_REQUIRE(nvlist_exists_string(nvl, key));
1153 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1154 static_cast<const char *>(NULL));
1157 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1158 cnvlist_free_string(nvl, cookie);
1161 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1162 ATF_REQUIRE(nvlist_empty(nvl));
1163 ATF_REQUIRE(!nvlist_exists(nvl, key));
1164 ATF_REQUIRE(!nvlist_exists_string(nvl, key));
1165 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1166 static_cast<const char *>(NULL));
1168 nvlist_destroy(nvl);
1171 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_nvlist);
1172 ATF_TEST_CASE_BODY(cnvlist_free_nvlist)
1174 nvlist_t *nvl, *value;
1175 const char *key, *subkey;
1179 nvl = nvlist_create(0);
1180 ATF_REQUIRE(nvl != NULL);
1181 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1182 ATF_REQUIRE(nvlist_empty(nvl));
1184 value = nvlist_create(0);
1185 ATF_REQUIRE(nvl != NULL);
1186 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1187 ATF_REQUIRE(nvlist_empty(nvl));
1193 /* Add null to 'value' nvlist. */
1194 nvlist_add_null(value, subkey);
1195 ATF_REQUIRE_EQ(strcmp(subkey, nvlist_next(value, &type, &cookie)), 0);
1196 ATF_REQUIRE_EQ(nvlist_error(value), 0);
1197 ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
1198 ATF_REQUIRE(!nvlist_empty(value));
1199 ATF_REQUIRE(nvlist_exists(value, subkey));
1200 ATF_REQUIRE(nvlist_exists_null(value, subkey));
1201 ATF_REQUIRE_EQ(nvlist_next(value, &type, &cookie),
1202 static_cast<const char *>(NULL));
1204 /* Add 'value' nvlist. */
1206 nvlist_move_nvlist(nvl, key, value);
1207 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1208 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1209 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
1210 ATF_REQUIRE(!nvlist_empty(nvl));
1211 ATF_REQUIRE(nvlist_exists(nvl, key));
1212 ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
1213 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1214 static_cast<const char *>(NULL));
1217 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1218 cnvlist_free_nvlist(nvl, cookie);
1221 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1222 ATF_REQUIRE(nvlist_empty(nvl));
1223 ATF_REQUIRE(!nvlist_exists(nvl, key));
1224 ATF_REQUIRE(!nvlist_exists_nvlist(nvl, key));
1225 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1226 static_cast<const char *>(NULL));
1228 nvlist_destroy(nvl);
1231 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_binary);
1232 ATF_TEST_CASE_BODY(cnvlist_free_binary)
1241 nvl = nvlist_create(0);
1242 ATF_REQUIRE(nvl != NULL);
1243 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1244 ATF_REQUIRE(nvlist_empty(nvl));
1249 in_binary = malloc(in_size);
1250 ATF_REQUIRE(in_binary != NULL);
1251 memset(in_binary, 0xa5, in_size);
1253 nvlist_add_binary(nvl, key, in_binary, in_size);
1254 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1255 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1256 ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
1257 ATF_REQUIRE(!nvlist_empty(nvl));
1258 ATF_REQUIRE(nvlist_exists(nvl, key));
1259 ATF_REQUIRE(nvlist_exists_binary(nvl, key));
1260 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1261 static_cast<const char *>(NULL));
1264 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1265 cnvlist_free_binary(nvl, cookie);
1268 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1269 ATF_REQUIRE(nvlist_empty(nvl));
1270 ATF_REQUIRE(!nvlist_exists(nvl, key));
1271 ATF_REQUIRE(!nvlist_exists_nvlist(nvl, key));
1272 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1273 static_cast<const char *>(NULL));
1275 nvlist_destroy(nvl);
1278 /* ATF cnvlist_free array tests. */
1280 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_bool_array);
1281 ATF_TEST_CASE_BODY(cnvlist_free_bool_array)
1289 for (i = 0; i < 16; i++)
1290 in_array[i] = (i % 2 == 0);
1292 nvl = nvlist_create(0);
1293 ATF_REQUIRE(nvl != NULL);
1294 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1295 ATF_REQUIRE(nvlist_empty(nvl));
1300 nvlist_add_bool_array(nvl, key, in_array, 16);
1301 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1302 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1303 ATF_REQUIRE_EQ(type, NV_TYPE_BOOL_ARRAY);
1304 ATF_REQUIRE(!nvlist_empty(nvl));
1305 ATF_REQUIRE(nvlist_exists(nvl, key));
1306 ATF_REQUIRE(nvlist_exists_bool_array(nvl, key));
1307 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1308 static_cast<const char *>(NULL));
1311 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1312 cnvlist_free_bool_array(nvl, cookie);
1315 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1316 ATF_REQUIRE(nvlist_empty(nvl));
1317 ATF_REQUIRE(!nvlist_exists(nvl, key));
1318 ATF_REQUIRE(!nvlist_exists_bool(nvl, key));
1319 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1320 static_cast<const char *>(NULL));
1322 nvlist_destroy(nvl);
1325 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_number_array);
1326 ATF_TEST_CASE_BODY(cnvlist_free_number_array)
1329 uint64_t in_array[16];
1334 for (i = 0; i < 16; i++)
1337 nvl = nvlist_create(0);
1338 ATF_REQUIRE(nvl != NULL);
1339 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1340 ATF_REQUIRE(nvlist_empty(nvl));
1345 nvlist_add_number_array(nvl, key, in_array, 16);
1346 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1347 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1348 ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER_ARRAY);
1349 ATF_REQUIRE(!nvlist_empty(nvl));
1350 ATF_REQUIRE(nvlist_exists(nvl, key));
1351 ATF_REQUIRE(nvlist_exists_number_array(nvl, key));
1352 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1353 static_cast<const char *>(NULL));
1356 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1357 cnvlist_free_number_array(nvl, cookie);
1360 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1361 ATF_REQUIRE(nvlist_empty(nvl));
1362 ATF_REQUIRE(!nvlist_exists(nvl, key));
1363 ATF_REQUIRE(!nvlist_exists_number_array(nvl, key));
1364 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1365 static_cast<const char *>(NULL));
1367 nvlist_destroy(nvl);
1370 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_string_array);
1371 ATF_TEST_CASE_BODY(cnvlist_free_string_array)
1374 const char *in_array[4] = {"inequality", "sucks", ".", ""};
1379 nvl = nvlist_create(0);
1380 ATF_REQUIRE(nvl != NULL);
1381 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1382 ATF_REQUIRE(nvlist_empty(nvl));
1387 nvlist_add_string_array(nvl, key, in_array, 4);
1388 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1389 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1390 ATF_REQUIRE_EQ(type, NV_TYPE_STRING_ARRAY);
1391 ATF_REQUIRE(!nvlist_empty(nvl));
1392 ATF_REQUIRE(nvlist_exists(nvl, key));
1393 ATF_REQUIRE(nvlist_exists_string_array(nvl, key));
1394 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1395 static_cast<const char *>(NULL));
1398 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1399 cnvlist_free_string_array(nvl, cookie);
1402 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1403 ATF_REQUIRE(nvlist_empty(nvl));
1404 ATF_REQUIRE(!nvlist_exists(nvl, key));
1405 ATF_REQUIRE(!nvlist_exists_string_array(nvl, key));
1406 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1407 static_cast<const char *>(NULL));
1409 nvlist_destroy(nvl);
1412 ATF_TEST_CASE_WITHOUT_HEAD(cnvlist_free_nvlist_array);
1413 ATF_TEST_CASE_BODY(cnvlist_free_nvlist_array)
1415 nvlist_t *testnvl[8];
1420 const char *somestr[8] = { "a", "b", "c", "d", "e", "f", "g", "h" };
1423 for (i = 0; i < 8; i++) {
1424 testnvl[i] = nvlist_create(0);
1425 ATF_REQUIRE(testnvl[i] != NULL);
1426 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0);
1427 ATF_REQUIRE(nvlist_empty(testnvl[i]));
1428 nvlist_add_string(testnvl[i], "nvl/string", somestr[i]);
1431 ATF_REQUIRE_EQ(strcmp("nvl/string", nvlist_next(testnvl[i],
1432 &type, &cookie)), 0);
1433 ATF_REQUIRE_EQ(nvlist_error(testnvl[i]), 0);
1434 ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
1435 ATF_REQUIRE(!nvlist_empty(testnvl[i]));
1436 ATF_REQUIRE(nvlist_exists(testnvl[i], "nvl/string"));
1437 ATF_REQUIRE(nvlist_exists_string(testnvl[i], "nvl/string"));
1438 ATF_REQUIRE_EQ(nvlist_next(testnvl[i], &type, &cookie),
1439 static_cast<const char *>(NULL));
1442 nvl = nvlist_create(0);
1443 ATF_REQUIRE(nvl != NULL);
1444 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1445 ATF_REQUIRE(nvlist_empty(nvl));
1450 nvlist_add_nvlist_array(nvl, key, (const nvlist_t * const *)testnvl, 8);
1451 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1452 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1453 ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST_ARRAY);
1454 ATF_REQUIRE(!nvlist_empty(nvl));
1455 ATF_REQUIRE(nvlist_exists(nvl, key));
1456 ATF_REQUIRE(nvlist_exists_nvlist_array(nvl, key));
1457 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1458 static_cast<const char *>(NULL));
1461 ATF_REQUIRE_EQ(strcmp(key, nvlist_next(nvl, &type, &cookie)), 0);
1462 cnvlist_free_nvlist_array(nvl, cookie);
1465 ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
1466 ATF_REQUIRE(nvlist_empty(nvl));
1467 ATF_REQUIRE(!nvlist_exists(nvl, key));
1468 ATF_REQUIRE(!nvlist_exists_nvlist_array(nvl, key));
1469 ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &cookie),
1470 static_cast<const char *>(NULL));
1472 for (i = 0; i < 8; i++)
1473 nvlist_destroy(testnvl[i]);
1474 nvlist_destroy(nvl);
1477 ATF_INIT_TEST_CASES(tp)
1479 ATF_ADD_TEST_CASE(tp, cnvlist_get_bool);
1480 ATF_ADD_TEST_CASE(tp, cnvlist_get_bool_array);
1481 ATF_ADD_TEST_CASE(tp, cnvlist_get_number);
1482 ATF_ADD_TEST_CASE(tp, cnvlist_get_string);
1483 ATF_ADD_TEST_CASE(tp, cnvlist_get_nvlist);
1484 ATF_ADD_TEST_CASE(tp, cnvlist_get_descriptor);
1485 ATF_ADD_TEST_CASE(tp, cnvlist_get_binary);
1486 ATF_ADD_TEST_CASE(tp, cnvlist_get_number_array);
1487 ATF_ADD_TEST_CASE(tp, cnvlist_get_string_array);
1488 ATF_ADD_TEST_CASE(tp, cnvlist_get_nvlist_array);
1489 ATF_ADD_TEST_CASE(tp, cnvlist_get_descriptor_array);
1490 ATF_ADD_TEST_CASE(tp, cnvlist_take_bool);
1491 ATF_ADD_TEST_CASE(tp, cnvlist_take_number);
1492 ATF_ADD_TEST_CASE(tp, cnvlist_take_string);
1493 ATF_ADD_TEST_CASE(tp, cnvlist_take_nvlist);
1494 ATF_ADD_TEST_CASE(tp, cnvlist_take_binary);
1495 ATF_ADD_TEST_CASE(tp, cnvlist_take_bool_array);
1496 ATF_ADD_TEST_CASE(tp, cnvlist_take_number_array);
1497 ATF_ADD_TEST_CASE(tp, cnvlist_take_string_array);
1498 ATF_ADD_TEST_CASE(tp, cnvlist_take_nvlist_array);
1499 ATF_ADD_TEST_CASE(tp, cnvlist_free_bool);
1500 ATF_ADD_TEST_CASE(tp, cnvlist_free_number);
1501 ATF_ADD_TEST_CASE(tp, cnvlist_free_string);
1502 ATF_ADD_TEST_CASE(tp, cnvlist_free_nvlist);
1503 ATF_ADD_TEST_CASE(tp, cnvlist_free_binary);
1504 ATF_ADD_TEST_CASE(tp, cnvlist_free_bool_array);
1505 ATF_ADD_TEST_CASE(tp, cnvlist_free_number_array);
1506 ATF_ADD_TEST_CASE(tp, cnvlist_free_string_array);
1507 ATF_ADD_TEST_CASE(tp, cnvlist_free_nvlist_array);