nv_tests.cc revision 302408 
1/*-
2 * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: stable/11/lib/libnv/tests/nv_tests.cc 285063 2015-07-02 21:58:10Z oshogbo $");
29
30#include <sys/nv.h>
31
32#include <atf-c++.hpp>
33
34#include <errno.h>
35#include <limits>
36#include <set>
37#include <sstream>
38#include <string>
39
40/*
41 * Test that a newly created nvlist has no errors, and is empty.
42 */
43ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
44ATF_TEST_CASE_BODY(nvlist_create__is_empty)
45{
46	nvlist_t *nvl;
47	int type;
48	void *it;
49
50	nvl = nvlist_create(0);
51
52	ATF_REQUIRE(nvl != NULL);
53
54	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
55	ATF_REQUIRE(nvlist_empty(nvl));
56
57	it = NULL;
58	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL));
59
60	nvlist_destroy(nvl);
61}
62
63ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
64ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
65{
66	nvlist_t *nvl;
67	void *it;
68	const char *key;
69	int type;
70
71	key = "key";
72	nvl = nvlist_create(0);
73
74	ATF_REQUIRE(nvl != NULL);
75	ATF_REQUIRE(!nvlist_exists(nvl, key));
76
77	nvlist_add_null(nvl, key);
78
79	ATF_REQUIRE(!nvlist_empty(nvl));
80	ATF_REQUIRE(nvlist_exists(nvl, key));
81	ATF_REQUIRE(nvlist_exists_null(nvl, key));
82	ATF_REQUIRE(nvlist_exists_null(nvl, "key"));
83
84	/* Iterate over the nvlist; ensure that it has only our one key. */
85	it = NULL;
86	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
87	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
88	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
89
90	nvlist_destroy(nvl);
91}
92
93ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
94ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
95{
96	nvlist_t *nvl;
97	void *it;
98	const char *key;
99	int type;
100
101	key = "name";
102	nvl = nvlist_create(0);
103
104	ATF_REQUIRE(nvl != NULL);
105	ATF_REQUIRE(!nvlist_exists(nvl, key));
106
107	nvlist_add_bool(nvl, key, true);
108
109	ATF_REQUIRE(!nvlist_empty(nvl));
110	ATF_REQUIRE(nvlist_exists(nvl, key));
111	ATF_REQUIRE(nvlist_exists(nvl, "name"));
112	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
113	ATF_REQUIRE(nvlist_exists_bool(nvl, "name"));
114	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
115
116	/* Iterate over the nvlist; ensure that it has only our one key. */
117	it = NULL;
118	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
119	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
120	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
121
122	nvlist_destroy(nvl);
123}
124
125ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
126ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
127{
128	nvlist_t *nvl;
129	void *it;
130	const char *key;
131	uint64_t value;
132	int type;
133
134	key = "foo123";
135	value = 71965;
136	nvl = nvlist_create(0);
137
138	ATF_REQUIRE(nvl != NULL);
139	ATF_REQUIRE(!nvlist_exists(nvl, key));
140
141	nvlist_add_number(nvl, key, value);
142
143	ATF_REQUIRE(!nvlist_empty(nvl));
144	ATF_REQUIRE(nvlist_exists(nvl, key));
145	ATF_REQUIRE(nvlist_exists(nvl, "foo123"));
146	ATF_REQUIRE(nvlist_exists_number(nvl, key));
147	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
148
149	/* Iterate over the nvlist; ensure that it has only our one key. */
150	it = NULL;
151	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
152	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
153	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
154
155	nvlist_destroy(nvl);
156}
157
158ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
159ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
160{
161	nvlist_t *nvl;
162	void *it;
163	const char *key;
164	const char *value;
165	int type;
166
167	key = "test";
168	value = "fgjdkgjdk";
169	nvl = nvlist_create(0);
170
171	ATF_REQUIRE(nvl != NULL);
172	ATF_REQUIRE(!nvlist_exists(nvl, key));
173
174	nvlist_add_string(nvl, key, value);
175
176	ATF_REQUIRE(!nvlist_empty(nvl));
177	ATF_REQUIRE(nvlist_exists(nvl, key));
178	ATF_REQUIRE(nvlist_exists(nvl, "test"));
179	ATF_REQUIRE(nvlist_exists_string(nvl, key));
180	ATF_REQUIRE(nvlist_exists_string(nvl, "test"));
181	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
182
183	/* nvlist_add_* is required to clone the value, so check for that. */
184	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
185
186	/* Iterate over the nvlist; ensure that it has only our one key. */
187	it = NULL;
188	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
189	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
190	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
191
192	nvlist_destroy(nvl);
193}
194
195ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
196ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
197{
198	nvlist_t *nvl;
199	void *it;
200	const char *key, *subkey;
201	nvlist_t *sublist;
202	const nvlist_t *value;
203	int type;
204
205	key = "test";
206	subkey = "subkey";
207	sublist = nvlist_create(0);
208	nvl = nvlist_create(0);
209
210	ATF_REQUIRE(nvl != NULL);
211	ATF_REQUIRE(!nvlist_exists(nvl, key));
212
213	nvlist_add_null(sublist, subkey);
214	nvlist_add_nvlist(nvl, key, sublist);
215
216	ATF_REQUIRE(!nvlist_empty(nvl));
217	ATF_REQUIRE(nvlist_exists(nvl, key));
218	ATF_REQUIRE(nvlist_exists(nvl, "test"));
219	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
220	ATF_REQUIRE(nvlist_exists_nvlist(nvl, "test"));
221
222	value = nvlist_get_nvlist(nvl, key);
223	ATF_REQUIRE(nvlist_exists_null(value, subkey));
224
225	/* nvlist_add_* is required to clone the value, so check for that. */
226	ATF_REQUIRE(sublist != value);
227
228	/* Iterate over the nvlist; ensure that it has only our one key. */
229	it = NULL;
230	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
231	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
232	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
233
234	nvlist_destroy(sublist);
235	nvlist_destroy(nvl);
236}
237
238ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__child_with_error);
239ATF_TEST_CASE_BODY(nvlist_add_nvlist__child_with_error)
240{
241	nvlist_t *nvl, *parent;
242
243	nvl = nvlist_create(0);
244	parent = nvlist_create(0);
245
246	nvlist_set_error(nvl, EBADF);
247	nvlist_add_nvlist(parent, "test", nvl);
248	ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
249
250	nvlist_destroy(nvl);
251	nvlist_destroy(parent);
252}
253
254ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
255ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
256{
257	nvlist_t *nvl;
258	void *it;
259	const char *key;
260	void *value;
261	const void *ret_value;
262	size_t value_size, ret_size;
263	int type;
264
265	key = "binary";
266	value_size = 13;
267	value = malloc(value_size);
268	memset(value, 0xa5, value_size);
269	nvl = nvlist_create(0);
270
271	ATF_REQUIRE(nvl != NULL);
272	ATF_REQUIRE(!nvlist_exists(nvl, key));
273
274	nvlist_add_binary(nvl, key, value, value_size);
275
276	ATF_REQUIRE(!nvlist_empty(nvl));
277	ATF_REQUIRE(nvlist_exists(nvl, key));
278	ATF_REQUIRE(nvlist_exists(nvl, "binary"));
279	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
280	ATF_REQUIRE(nvlist_exists_binary(nvl, "binary"));
281
282	ret_value = nvlist_get_binary(nvl, key, &ret_size);
283	ATF_REQUIRE_EQ(value_size, ret_size);
284	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
285
286	/* nvlist_add_* is required to clone the value, so check for that. */
287	ATF_REQUIRE(value != ret_value);
288
289	/* Iterate over the nvlist; ensure that it has only our one key. */
290	it = NULL;
291	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
292	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
293	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
294
295	nvlist_destroy(nvl);
296	free(value);
297}
298
299ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
300ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
301{
302	nvlist_t *nvl, *clone;
303
304	nvl = nvlist_create(0);
305	ATF_REQUIRE(nvl != NULL);
306
307	clone = nvlist_clone(nvl);
308	ATF_REQUIRE(clone != NULL);
309	ATF_REQUIRE(clone != nvl);
310	ATF_REQUIRE(nvlist_empty(clone));
311
312	nvlist_destroy(clone);
313	nvlist_destroy(nvl);
314}
315
316ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
317ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
318{
319	nvlist_t *nvl, *clone;
320	const char *key;
321	void *it;
322	uint64_t value;
323	int type;
324
325	nvl = nvlist_create(0);
326	ATF_REQUIRE(nvl != NULL);
327
328	key = "testkey";
329	value = 684874;
330	nvlist_add_number(nvl, key, value);
331
332	clone = nvlist_clone(nvl);
333	ATF_REQUIRE(clone != NULL);
334	ATF_REQUIRE(clone != nvl);
335	ATF_REQUIRE(nvlist_exists_number(clone, key));
336	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
337
338	/* Iterate over the nvlist; ensure that it has only our one key. */
339	it = NULL;
340	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
341	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
342	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), static_cast<const char *>(NULL));
343
344	nvlist_destroy(clone);
345	nvlist_destroy(nvl);
346}
347
348static const char * const test_subnvlist_key = "nvlist";
349
350static const char * const test_string_key = "string";
351static const char * const test_string_val = "59525";
352
353static nvlist_t*
354create_test_nvlist(void)
355{
356	nvlist_t *nvl, *sublist;
357
358	nvl = nvlist_create(0);
359	ATF_REQUIRE(nvl != NULL);
360
361	sublist = nvlist_create(0);
362	ATF_REQUIRE(sublist != NULL);
363
364	nvlist_add_string(sublist, test_string_key, test_string_val);
365	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
366
367	return (nvl);
368}
369
370static void
371verify_test_nvlist(const nvlist_t *nvl)
372{
373	void *it;
374	const nvlist_t *value;
375	int type;
376
377	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
378
379	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
380
381	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
382	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
383	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
384
385	/* Iterate over both nvlists; ensure that each has only the one key. */
386	it = NULL;
387	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
388	    test_string_key), 0);
389	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
390	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), static_cast<const char *>(NULL));
391
392	it = NULL;
393	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
394	    test_subnvlist_key), 0);
395	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
396	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL));
397}
398
399ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
400ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
401{
402	nvlist_t *nvl, *clone;
403
404	nvl = create_test_nvlist();
405	clone = nvlist_clone(nvl);
406
407	ATF_REQUIRE(clone != NULL);
408	ATF_REQUIRE(clone != nvl);
409	verify_test_nvlist(clone);
410
411	nvlist_destroy(clone);
412	nvlist_destroy(nvl);
413}
414
415ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__error_nvlist);
416ATF_TEST_CASE_BODY(nvlist_clone__error_nvlist)
417{
418	nvlist_t *nvl, *clone;
419
420	nvl = nvlist_create(0);
421	ATF_REQUIRE(nvl != NULL);
422
423	nvlist_set_error(nvl, ENOMEM);
424
425	clone = nvlist_clone(nvl);
426	ATF_REQUIRE(clone == NULL);
427
428	nvlist_destroy(nvl);
429}
430
431ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
432ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
433{
434	nvlist_t *nvl, *unpacked;
435	void *packed;
436	size_t packed_size;
437
438	nvl = nvlist_create(0);
439	ATF_REQUIRE(nvl != NULL);
440
441	packed = nvlist_pack(nvl, &packed_size);
442	ATF_REQUIRE(packed != NULL);
443
444	unpacked = nvlist_unpack(packed, packed_size, 0);
445	ATF_REQUIRE(unpacked != NULL);
446	ATF_REQUIRE(unpacked != nvl);
447	ATF_REQUIRE(nvlist_empty(unpacked));
448
449	nvlist_destroy(unpacked);
450	nvlist_destroy(nvl);
451	free(packed);
452}
453
454ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__flags_nvlist);
455ATF_TEST_CASE_BODY(nvlist_unpack__flags_nvlist)
456{
457	nvlist_t *nvl, *unpacked;
458	void *packed;
459	size_t packed_size;
460
461	nvl = nvlist_create(NV_FLAG_NO_UNIQUE);
462	ATF_REQUIRE(nvl != NULL);
463
464	nvlist_add_bool(nvl, "name", true);
465	ATF_REQUIRE(!nvlist_empty(nvl));
466	ATF_REQUIRE(nvlist_exists_bool(nvl, "name"));
467
468	packed = nvlist_pack(nvl, &packed_size);
469	ATF_REQUIRE(packed != NULL);
470
471	unpacked = nvlist_unpack(packed, packed_size, 0);
472	ATF_REQUIRE(unpacked == NULL);
473
474	unpacked = nvlist_unpack(packed, packed_size, NV_FLAG_IGNORE_CASE);
475	ATF_REQUIRE(unpacked == NULL);
476
477	unpacked = nvlist_unpack(packed, packed_size, NV_FLAG_NO_UNIQUE);
478	ATF_REQUIRE(unpacked != NULL);
479	ATF_REQUIRE(unpacked != nvl);
480	ATF_REQUIRE(!nvlist_empty(unpacked));
481	ATF_REQUIRE(nvlist_exists_bool(unpacked, "name"));
482
483	nvlist_destroy(unpacked);
484	nvlist_destroy(nvl);
485	free(packed);
486}
487
488static void
489verify_null(const nvlist_t *nvl, int type)
490{
491
492	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
493}
494
495static void
496verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
497{
498
499	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
500	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
501}
502
503static void
504verify_string(const nvlist_t *nvl, const char *name, int type,
505    const char * value)
506{
507
508	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
509	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
510}
511
512static void
513verify_nvlist(const nvlist_t *nvl, const char *name, int type)
514{
515
516	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
517	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
518}
519
520static void
521verify_binary(const nvlist_t *nvl, const char *name, int type,
522    const void * value, size_t size)
523{
524	const void *actual_value;
525	size_t actual_size;
526
527	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
528	actual_value = nvlist_get_binary(nvl, name, &actual_size);
529	ATF_REQUIRE_EQ(size, actual_size);
530	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
531}
532
533ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
534ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
535{
536	std::ostringstream msg;
537	std::set<std::string> keys_seen;
538	nvlist_t *nvl, *unpacked, *nvvalue;
539	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
540	int numvalue;
541	const char * strvalue;
542	void *binvalue, *packed, *it;
543	size_t binsize, packed_size;
544	int type;
545
546	nvl = nvlist_create(0);
547
548	nullkey = "null";
549	nvlist_add_null(nvl, nullkey);
550
551	numkey = "number";
552	numvalue = 939853984;
553	nvlist_add_number(nvl, numkey, numvalue);
554
555	strkey = "string";
556	strvalue = "jfieutijf";
557	nvlist_add_string(nvl, strkey, strvalue);
558
559	nvkey = "nvlist";
560	nvvalue = create_test_nvlist();
561	nvlist_move_nvlist(nvl, nvkey, nvvalue);
562
563	binkey = "binary";
564	binsize = 4;
565	binvalue = malloc(binsize);
566	memset(binvalue, 'b', binsize);
567	nvlist_move_binary(nvl, binkey, binvalue, binsize);
568
569	packed = nvlist_pack(nvl, &packed_size);
570	ATF_REQUIRE(packed != NULL);
571
572	unpacked = nvlist_unpack(packed, packed_size, 0);
573	ATF_REQUIRE(unpacked != 0);
574
575	it = NULL;
576	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
577		/* Ensure that we see every key only once. */
578		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
579
580		if (strcmp(name, nullkey) == 0)
581			verify_null(unpacked, type);
582		else if (strcmp(name, numkey) == 0)
583			verify_number(unpacked, name, type, numvalue);
584		else if (strcmp(name, strkey) == 0)
585			verify_string(unpacked, name, type, strvalue);
586		else if (strcmp(name, nvkey) == 0)
587			verify_nvlist(unpacked, name, type);
588		else if (strcmp(name, binkey) == 0)
589			verify_binary(unpacked, name, type, binvalue, binsize);
590		else {
591			msg << "Unexpected key :'" << name << "'";
592			ATF_FAIL(msg.str().c_str());
593		}
594
595		keys_seen.insert(name);
596	}
597
598	/* Ensure that we saw every key. */
599	ATF_REQUIRE_EQ(keys_seen.size(), 5);
600
601	nvlist_destroy(nvl);
602	nvlist_destroy(unpacked);
603	free(packed);
604}
605
606ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__error_nvlist);
607ATF_TEST_CASE_BODY(nvlist_pack__error_nvlist)
608{
609	nvlist_t *nvl;
610	void *packed;
611	size_t size;
612
613	nvl = nvlist_create(0);
614	ATF_REQUIRE(nvl != NULL);
615
616	nvlist_set_error(nvl, ENOMEM);
617
618	packed = nvlist_pack(nvl, &size);
619	ATF_REQUIRE(packed == NULL);
620
621	nvlist_destroy(nvl);
622}
623
624ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
625ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
626{
627	nvlist_t *nvl, *unpacked;
628	const char *key1, *key2;
629	void *packed, *keypos;
630	size_t size, keylen;
631
632	nvl = nvlist_create(0);
633
634	key1 = "key1";
635	keylen = strlen(key1);
636	nvlist_add_number(nvl, key1, 5);
637
638	key2 = "key2";
639	ATF_REQUIRE_EQ(keylen, strlen(key2));
640	nvlist_add_number(nvl, key2, 10);
641
642	packed = nvlist_pack(nvl, &size);
643
644	/*
645	 * Mangle the packed nvlist by replacing key1 with key2, creating a
646	 * packed nvlist with a duplicate key.
647	 */
648	keypos = memmem(packed, size, key1, keylen);
649	ATF_REQUIRE(keypos != NULL);
650	memcpy(keypos, key2, keylen);
651
652	unpacked = nvlist_unpack(packed, size, 0);
653	ATF_REQUIRE(nvlist_error(unpacked) != 0);
654
655	free(packed);
656	nvlist_destroy(nvl);
657	nvlist_destroy(unpacked);
658}
659
660ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
661ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
662{
663	nvlist_t *nvl;
664	const char *key;
665	char *value;
666
667	nvl = nvlist_create(0);
668	ATF_REQUIRE(nvl != NULL);
669
670	key = "testkey";
671	value = strdup("testval");
672	ATF_REQUIRE(value != NULL);
673
674	nvlist_move_string(nvl, key, value);
675	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
676
677	nvlist_destroy(nvl);
678}
679
680ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
681ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
682{
683	nvlist_t *parent;
684
685	parent = nvlist_create(0);
686
687	nvlist_move_nvlist(parent, "test", NULL);
688
689	ATF_REQUIRE(nvlist_error(parent) != 0);
690
691	nvlist_destroy(parent);
692}
693
694ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__child_with_error);
695ATF_TEST_CASE_BODY(nvlist_move_nvlist__child_with_error)
696{
697	nvlist_t *nvl, *parent;
698
699	nvl = nvlist_create(0);
700	parent = nvlist_create(0);
701
702	nvlist_set_error(nvl, EBADF);
703	nvlist_move_nvlist(parent, "test", nvl);
704	ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
705
706	nvlist_destroy(parent);
707}
708
709ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
710ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
711{
712	nvlist_t *nvl;
713	const char *key;
714	nvlist_t *value;
715
716	nvl = nvlist_create(0);
717	ATF_REQUIRE(nvl != NULL);
718
719	key = "testkey";
720	value = nvlist_create(0);
721	ATF_REQUIRE(value != NULL);
722
723	nvlist_move_nvlist(nvl, key, value);
724	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
725
726	nvlist_destroy(nvl);
727}
728
729ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
730ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
731{
732	nvlist_t *nvl;
733	const char *key;
734	void *value;
735	size_t size, actual_size;
736
737	nvl = nvlist_create(0);
738	ATF_REQUIRE(nvl != NULL);
739
740	key = "testkey";
741	size = 73;
742	value = malloc(size);
743	ATF_REQUIRE(value != NULL);
744
745	nvlist_move_binary(nvl, key, value, size);
746	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
747	ATF_REQUIRE_EQ(size, actual_size);
748
749	nvlist_destroy(nvl);
750}
751
752ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
753ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
754{
755	nvlist_t *nvl;
756	const char *testkey;
757	bool testval;
758
759	nvl = nvlist_create(0);
760	ATF_REQUIRE(nvl != NULL);
761
762	testkey = "boolkey";
763	testval = false;
764	nvlist_add_bool(nvl, testkey, testval);
765
766	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
767	ATF_REQUIRE(nvlist_empty(nvl));
768
769	nvlist_destroy(nvl);
770}
771
772ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
773ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
774{
775	nvlist_t *nvl;
776	const char *testkey, *otherkey1, *otherkey2;
777	bool testval, otherval1;
778	nvlist_t *otherval2;
779
780	nvl = nvlist_create(0);
781	ATF_REQUIRE(nvl != NULL);
782
783	testkey = "boolkey";
784	testval = true;
785	nvlist_add_bool(nvl, testkey, testval);
786
787	otherkey1 = "key1";
788	otherval1 = false;
789	nvlist_add_bool(nvl, otherkey1, otherval1);
790
791	otherkey2 = "key2";
792	otherval2 = create_test_nvlist();
793	nvlist_move_nvlist(nvl, otherkey2, otherval2);
794
795	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
796
797	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
798	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
799
800	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
801	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
802
803	nvlist_destroy(nvl);
804}
805
806ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
807ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
808{
809	nvlist_t *nvl;
810	const char *testkey;
811	uint64_t testval;
812
813	nvl = nvlist_create(0);
814	ATF_REQUIRE(nvl != NULL);
815
816	testkey = "numkey";
817	testval = std::numeric_limits<uint64_t>::max();
818	nvlist_add_number(nvl, testkey, testval);
819
820	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
821	ATF_REQUIRE(nvlist_empty(nvl));
822
823	nvlist_destroy(nvl);
824}
825
826ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
827ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
828{
829	nvlist_t *nvl;
830	const char *testkey, *otherkey1, *otherkey2;
831	uint64_t testval, otherval1;
832	const char *otherval2;
833
834	nvl = nvlist_create(0);
835	ATF_REQUIRE(nvl != NULL);
836
837	otherkey1 = "key1";
838	otherval1 = 5;
839	nvlist_add_number(nvl, otherkey1, otherval1);
840
841	testkey = "numkey";
842	testval = 1654;
843	nvlist_add_number(nvl, testkey, testval);
844
845	otherkey2 = "key2";
846	otherval2 = "string";
847	nvlist_add_string(nvl, otherkey2, otherval2);
848
849	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
850
851	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
852	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
853
854	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
855	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
856
857	nvlist_destroy(nvl);
858}
859
860ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
861ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
862{
863	nvlist_t *nvl;
864	const char *testkey;
865	const char *testval;
866
867	nvl = nvlist_create(0);
868	ATF_REQUIRE(nvl != NULL);
869
870	testkey = "numkey";
871	testval = "nvlist";
872	nvlist_add_string(nvl, testkey, testval);
873
874	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
875	ATF_REQUIRE(nvlist_empty(nvl));
876
877	nvlist_destroy(nvl);
878}
879
880ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
881ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
882{
883	nvlist_t *nvl;
884	const char *testkey, *otherkey1, *otherkey2;
885	const char *testval, *otherval1;
886	bool otherval2;
887
888	nvl = nvlist_create(0);
889	ATF_REQUIRE(nvl != NULL);
890
891	otherkey1 = "key1";
892	otherval1 = "fjdifjdk";
893	nvlist_add_string(nvl, otherkey1, otherval1);
894
895	otherkey2 = "key2";
896	otherval2 = true;
897	nvlist_add_bool(nvl, otherkey2, otherval2);
898
899	testkey = "strkey";
900	testval = "1654";
901	nvlist_add_string(nvl, testkey, testval);
902
903	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
904
905	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
906	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
907
908	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
909	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
910
911	nvlist_destroy(nvl);
912}
913
914ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
915ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
916{
917	nvlist_t *nvl;
918	const char *testkey;
919	nvlist_t *testval;
920
921	nvl = nvlist_create(0);
922	ATF_REQUIRE(nvl != NULL);
923
924	testkey = "numkey";
925	testval = create_test_nvlist();
926	nvlist_move_nvlist(nvl, testkey, testval);
927
928	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
929	ATF_REQUIRE(nvlist_empty(nvl));
930
931	nvlist_destroy(nvl);
932}
933
934ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
935ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
936{
937	nvlist_t *nvl;
938	const char *testkey, *otherkey1, *otherkey2;
939	nvlist_t *testval, *otherval1;
940
941	nvl = nvlist_create(0);
942	ATF_REQUIRE(nvl != NULL);
943
944	testkey = "strkey";
945	testval = create_test_nvlist();
946	nvlist_move_nvlist(nvl, testkey, testval);
947
948	otherkey1 = "key1";
949	otherval1 = nvlist_create(0);
950	nvlist_move_nvlist(nvl, otherkey1, otherval1);
951
952	otherkey2 = "key2";
953	nvlist_add_null(nvl, otherkey2);
954
955	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
956
957	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
958	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
959
960	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
961
962	nvlist_destroy(nvl);
963}
964
965ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
966ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
967{
968	nvlist_t *nvl;
969	const char *testkey;
970	void *testval;
971	const void *actual_val;
972	size_t testsize, actual_size;
973
974	nvl = nvlist_create(0);
975	ATF_REQUIRE(nvl != NULL);
976
977	testkey = "numkey";
978	testsize = 457;
979	testval = malloc(testsize);
980	memset(testval, '5', testsize);
981	nvlist_move_binary(nvl, testkey, testval, testsize);
982
983	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
984	ATF_REQUIRE_EQ(testsize, actual_size);
985	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
986	ATF_REQUIRE(nvlist_empty(nvl));
987
988	nvlist_destroy(nvl);
989}
990
991ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
992ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
993{
994	nvlist_t *nvl;
995	const char *testkey, *otherkey1, *otherkey2;
996	const void *actual_value;
997	char testval[] = "gjiertj";
998	char otherval1[] = "fdreg";
999	size_t testsize, othersize, actual_size;
1000	bool otherval2;
1001
1002	nvl = nvlist_create(0);
1003	ATF_REQUIRE(nvl != NULL);
1004
1005	otherkey1 = "key1";
1006	othersize = sizeof(otherval1);
1007	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
1008
1009	otherkey2 = "key2";
1010	otherval2 = true;
1011	nvlist_add_bool(nvl, otherkey2, otherval2);
1012
1013	testkey = "strkey";
1014	testsize = sizeof(testval);
1015	nvlist_add_binary(nvl, testkey, testval, testsize);
1016
1017	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
1018	ATF_REQUIRE_EQ(testsize, actual_size);
1019	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
1020
1021	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
1022	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
1023	ATF_REQUIRE_EQ(othersize, actual_size);
1024	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
1025
1026	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
1027	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
1028
1029	nvlist_destroy(nvl);
1030}
1031
1032ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
1033ATF_TEST_CASE_BODY(nvlist_free__single_null)
1034{
1035	nvlist_t *nvl;
1036	const char *key;
1037
1038	nvl = nvlist_create(0);
1039	key = "test";
1040	nvlist_add_null(nvl, key);
1041
1042	nvlist_free(nvl, key);
1043	ATF_REQUIRE(nvlist_empty(nvl));
1044
1045	nvlist_destroy(nvl);
1046}
1047
1048ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
1049ATF_TEST_CASE_BODY(nvlist_free__single_bool)
1050{
1051	nvlist_t *nvl;
1052	const char *key;
1053
1054	nvl = nvlist_create(0);
1055	key = "test";
1056	nvlist_add_bool(nvl, key, true);
1057
1058	nvlist_free(nvl, key);
1059	ATF_REQUIRE(nvlist_empty(nvl));
1060
1061	nvlist_destroy(nvl);
1062}
1063
1064ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
1065ATF_TEST_CASE_BODY(nvlist_free__single_number)
1066{
1067	nvlist_t *nvl;
1068	const char *key;
1069
1070	nvl = nvlist_create(0);
1071	key = "test";
1072	nvlist_add_number(nvl, key, 584);
1073
1074	nvlist_free(nvl, key);
1075	ATF_REQUIRE(nvlist_empty(nvl));
1076
1077	nvlist_destroy(nvl);
1078}
1079
1080ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
1081ATF_TEST_CASE_BODY(nvlist_free__single_string)
1082{
1083	nvlist_t *nvl;
1084	const char *key;
1085
1086	nvl = nvlist_create(0);
1087	key = "test";
1088	nvlist_add_string(nvl, key, "gjkfkjd");
1089
1090	nvlist_free(nvl, key);
1091	ATF_REQUIRE(nvlist_empty(nvl));
1092
1093	nvlist_destroy(nvl);
1094}
1095
1096ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
1097ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
1098{
1099	nvlist_t *nvl;
1100	const char *key;
1101
1102	nvl = nvlist_create(0);
1103	key = "test";
1104	nvlist_add_nvlist(nvl, key, nvlist_create(0));
1105
1106	nvlist_free(nvl, key);
1107	ATF_REQUIRE(nvlist_empty(nvl));
1108
1109	nvlist_destroy(nvl);
1110}
1111
1112ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
1113ATF_TEST_CASE_BODY(nvlist_free__single_binary)
1114{
1115	nvlist_t *nvl;
1116	const char *key;
1117
1118	nvl = nvlist_create(0);
1119	key = "test";
1120	nvlist_add_binary(nvl, key, "jgjgfd", 6);
1121
1122	nvlist_free(nvl, key);
1123	ATF_REQUIRE(nvlist_empty(nvl));
1124
1125	nvlist_destroy(nvl);
1126}
1127
1128ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
1129ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
1130{
1131	nvlist_t *nvl;
1132	const char *key;
1133
1134	nvl = nvlist_create(0);
1135	key = "test";
1136	nvlist_add_null(nvl, key);
1137
1138	nvlist_free_null(nvl, key);
1139	ATF_REQUIRE(nvlist_empty(nvl));
1140
1141	nvlist_destroy(nvl);
1142}
1143
1144ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
1145ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
1146{
1147	nvlist_t *nvl;
1148	const char *key;
1149
1150	nvl = nvlist_create(0);
1151	key = "test";
1152	nvlist_add_bool(nvl, key, true);
1153
1154	nvlist_free_bool(nvl, key);
1155	ATF_REQUIRE(nvlist_empty(nvl));
1156
1157	nvlist_destroy(nvl);
1158}
1159
1160ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
1161ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
1162{
1163	nvlist_t *nvl;
1164	const char *key;
1165
1166	nvl = nvlist_create(0);
1167	key = "test";
1168	nvlist_add_number(nvl, key, 584);
1169
1170	nvlist_free_number(nvl, key);
1171	ATF_REQUIRE(nvlist_empty(nvl));
1172
1173	nvlist_destroy(nvl);
1174}
1175
1176ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
1177ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
1178{
1179	nvlist_t *nvl;
1180	const char *key;
1181
1182	nvl = nvlist_create(0);
1183	key = "test";
1184	nvlist_add_string(nvl, key, "gjkfkjd");
1185
1186	nvlist_free_string(nvl, key);
1187	ATF_REQUIRE(nvlist_empty(nvl));
1188
1189	nvlist_destroy(nvl);
1190}
1191
1192ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
1193ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
1194{
1195	nvlist_t *nvl;
1196	const char *key;
1197
1198	nvl = nvlist_create(0);
1199	key = "test";
1200	nvlist_add_nvlist(nvl, key, nvlist_create(0));
1201
1202	nvlist_free_nvlist(nvl, key);
1203	ATF_REQUIRE(nvlist_empty(nvl));
1204
1205	nvlist_destroy(nvl);
1206}
1207
1208ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
1209ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
1210{
1211	nvlist_t *nvl;
1212	const char *key;
1213
1214	nvl = nvlist_create(0);
1215	key = "test";
1216	nvlist_add_binary(nvl, key, "jgjgfd", 6);
1217
1218	nvlist_free_binary(nvl, key);
1219	ATF_REQUIRE(nvlist_empty(nvl));
1220
1221	nvlist_destroy(nvl);
1222}
1223
1224ATF_INIT_TEST_CASES(tp)
1225{
1226	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
1227	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
1228	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
1229	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
1230	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
1231	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
1232	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__child_with_error);
1233	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
1234
1235	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
1236	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
1237	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
1238	ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist);
1239
1240	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
1241	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
1242	ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist);
1243	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
1244	ATF_ADD_TEST_CASE(tp, nvlist_unpack__flags_nvlist);
1245
1246	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
1247	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
1248	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
1249	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__child_with_error);
1250	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
1251
1252	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
1253	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
1254	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
1255	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
1256	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
1257	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
1258	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
1259	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
1260	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
1261	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
1262
1263	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
1264	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
1265	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
1266	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
1267	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
1268	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
1269
1270	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
1271	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
1272	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
1273	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
1274	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
1275	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
1276}
1277