Index: head/lib/libnv/nvpair.c =================================================================== --- head/lib/libnv/nvpair.c (revision 279435) +++ head/lib/libnv/nvpair.c (revision 279436) @@ -1,1304 +1,1310 @@ /*- * Copyright (c) 2009-2013 The FreeBSD Foundation * All rights reserved. * * This software was developed by Pawel Jakub Dawidek under sponsorship from * the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_PJDLOG #include #endif #include "common_impl.h" #include "nv.h" #include "nv_impl.h" #include "nvlist_impl.h" #include "nvpair_impl.h" #ifndef HAVE_PJDLOG #include #define PJDLOG_ASSERT(...) assert(__VA_ARGS__) #define PJDLOG_RASSERT(expr, ...) assert(expr) #define PJDLOG_ABORT(...) abort() #endif #define NVPAIR_MAGIC 0x6e7670 /* "nvp" */ struct nvpair { int nvp_magic; char *nvp_name; int nvp_type; uint64_t nvp_data; size_t nvp_datasize; nvlist_t *nvp_list; TAILQ_ENTRY(nvpair) nvp_next; }; #define NVPAIR_ASSERT(nvp) do { \ PJDLOG_ASSERT((nvp) != NULL); \ PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC); \ } while (0) struct nvpair_header { uint8_t nvph_type; uint16_t nvph_namesize; uint64_t nvph_datasize; } __packed; void nvpair_assert(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); } nvlist_t * nvpair_nvlist(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); return (nvp->nvp_list); } nvpair_t * nvpair_next(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_list != NULL); return (TAILQ_NEXT(nvp, nvp_next)); } nvpair_t * nvpair_prev(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_list != NULL); return (TAILQ_PREV(nvp, nvl_head, nvp_next)); } void nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_list == NULL); PJDLOG_ASSERT(!nvlist_exists(nvl, nvpair_name(nvp))); TAILQ_INSERT_TAIL(head, nvp, nvp_next); nvp->nvp_list = nvl; } static void nvpair_remove_nvlist(nvpair_t *nvp) { nvlist_t *nvl; /* XXX: DECONST is bad, mkay? */ nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp)); PJDLOG_ASSERT(nvl != NULL); nvlist_set_parent(nvl, NULL); } void nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_list == nvl); if (nvpair_type(nvp) == NV_TYPE_NVLIST) nvpair_remove_nvlist(nvp); TAILQ_REMOVE(head, nvp, nvp_next); nvp->nvp_list = NULL; } nvpair_t * nvpair_clone(const nvpair_t *nvp) { nvpair_t *newnvp; const char *name; const void *data; size_t datasize; NVPAIR_ASSERT(nvp); name = nvpair_name(nvp); switch (nvpair_type(nvp)) { case NV_TYPE_NULL: newnvp = nvpair_create_null(name); break; case NV_TYPE_BOOL: newnvp = nvpair_create_bool(name, nvpair_get_bool(nvp)); break; case NV_TYPE_NUMBER: newnvp = nvpair_create_number(name, nvpair_get_number(nvp)); break; case NV_TYPE_STRING: newnvp = nvpair_create_string(name, nvpair_get_string(nvp)); break; case NV_TYPE_NVLIST: newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp)); break; case NV_TYPE_DESCRIPTOR: newnvp = nvpair_create_descriptor(name, nvpair_get_descriptor(nvp)); break; case NV_TYPE_BINARY: data = nvpair_get_binary(nvp, &datasize); newnvp = nvpair_create_binary(name, data, datasize); break; default: PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp)); } return (newnvp); } size_t nvpair_header_size(void) { return (sizeof(struct nvpair_header)); } size_t nvpair_size(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); return (nvp->nvp_datasize); } unsigned char * nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp) { struct nvpair_header nvphdr; size_t namesize; NVPAIR_ASSERT(nvp); nvphdr.nvph_type = nvp->nvp_type; namesize = strlen(nvp->nvp_name) + 1; PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX); nvphdr.nvph_namesize = namesize; nvphdr.nvph_datasize = nvp->nvp_datasize; PJDLOG_ASSERT(*leftp >= sizeof(nvphdr)); memcpy(ptr, &nvphdr, sizeof(nvphdr)); ptr += sizeof(nvphdr); *leftp -= sizeof(nvphdr); PJDLOG_ASSERT(*leftp >= namesize); memcpy(ptr, nvp->nvp_name, namesize); ptr += namesize; *leftp -= namesize; return (ptr); } unsigned char * nvpair_pack_null(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp __unused) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL); return (ptr); } unsigned char * nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp) { uint8_t value; NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL); value = (uint8_t)nvp->nvp_data; PJDLOG_ASSERT(*leftp >= sizeof(value)); memcpy(ptr, &value, sizeof(value)); ptr += sizeof(value); *leftp -= sizeof(value); return (ptr); } unsigned char * nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp) { uint64_t value; NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER); value = (uint64_t)nvp->nvp_data; PJDLOG_ASSERT(*leftp >= sizeof(value)); memcpy(ptr, &value, sizeof(value)); ptr += sizeof(value); *leftp -= sizeof(value); return (ptr); } unsigned char * nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING); PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize); memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize); ptr += nvp->nvp_datasize; *leftp -= nvp->nvp_datasize; return (ptr); } unsigned char * nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp) { struct nvpair_header nvphdr; size_t namesize; const char *name = ""; namesize = 1; nvphdr.nvph_type = NV_TYPE_NVLIST_UP; nvphdr.nvph_namesize = namesize; nvphdr.nvph_datasize = 0; PJDLOG_ASSERT(*leftp >= sizeof(nvphdr)); memcpy(ptr, &nvphdr, sizeof(nvphdr)); ptr += sizeof(nvphdr); *leftp -= sizeof(nvphdr); PJDLOG_ASSERT(*leftp >= namesize); memcpy(ptr, name, namesize); ptr += namesize; *leftp -= namesize; return (ptr); } unsigned char * nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp, size_t *leftp) { int64_t value; NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR); value = (int64_t)nvp->nvp_data; if (value != -1) { /* * If there is a real descriptor here, we change its number * to position in the array of descriptors send via control * message. */ PJDLOG_ASSERT(fdidxp != NULL); value = *fdidxp; (*fdidxp)++; } PJDLOG_ASSERT(*leftp >= sizeof(value)); memcpy(ptr, &value, sizeof(value)); ptr += sizeof(value); *leftp -= sizeof(value); return (ptr); } unsigned char * nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY); PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize); memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize); ptr += nvp->nvp_datasize; *leftp -= nvp->nvp_datasize; return (ptr); } void nvpair_init_datasize(nvpair_t *nvp) { NVPAIR_ASSERT(nvp); if (nvp->nvp_type == NV_TYPE_NVLIST) { if (nvp->nvp_data == 0) { nvp->nvp_datasize = 0; } else { nvp->nvp_datasize = nvlist_size((const nvlist_t *)(intptr_t)nvp->nvp_data); } } } const unsigned char * nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp) { struct nvpair_header nvphdr; if (*leftp < sizeof(nvphdr)) goto failed; memcpy(&nvphdr, ptr, sizeof(nvphdr)); ptr += sizeof(nvphdr); *leftp -= sizeof(nvphdr); #if NV_TYPE_FIRST > 0 if (nvphdr.nvph_type < NV_TYPE_FIRST) goto failed; #endif if (nvphdr.nvph_type > NV_TYPE_LAST && nvphdr.nvph_type != NV_TYPE_NVLIST_UP) { goto failed; } #if BYTE_ORDER == BIG_ENDIAN if (!isbe) { nvphdr.nvph_namesize = le16toh(nvphdr.nvph_namesize); nvphdr.nvph_datasize = le64toh(nvphdr.nvph_datasize); } #else if (isbe) { nvphdr.nvph_namesize = be16toh(nvphdr.nvph_namesize); nvphdr.nvph_datasize = be64toh(nvphdr.nvph_datasize); } #endif if (nvphdr.nvph_namesize > NV_NAME_MAX) goto failed; if (*leftp < nvphdr.nvph_namesize) goto failed; if (nvphdr.nvph_namesize < 1) goto failed; if (strnlen((const char *)ptr, nvphdr.nvph_namesize) != (size_t)(nvphdr.nvph_namesize - 1)) { goto failed; } memcpy(nvp->nvp_name, ptr, nvphdr.nvph_namesize); ptr += nvphdr.nvph_namesize; *leftp -= nvphdr.nvph_namesize; if (*leftp < nvphdr.nvph_datasize) goto failed; nvp->nvp_type = nvphdr.nvph_type; nvp->nvp_data = 0; nvp->nvp_datasize = nvphdr.nvph_datasize; return (ptr); failed: errno = EINVAL; return (NULL); } const unsigned char * nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp __unused) { PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL); if (nvp->nvp_datasize != 0) { errno = EINVAL; return (NULL); } return (ptr); } const unsigned char * nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp) { uint8_t value; PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL); if (nvp->nvp_datasize != sizeof(value)) { errno = EINVAL; return (NULL); } if (*leftp < sizeof(value)) { errno = EINVAL; return (NULL); } memcpy(&value, ptr, sizeof(value)); ptr += sizeof(value); *leftp -= sizeof(value); if (value != 0 && value != 1) { errno = EINVAL; return (NULL); } nvp->nvp_data = (uint64_t)value; return (ptr); } const unsigned char * nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp) { PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER); if (nvp->nvp_datasize != sizeof(uint64_t)) { errno = EINVAL; return (NULL); } if (*leftp < sizeof(uint64_t)) { errno = EINVAL; return (NULL); } if (isbe) nvp->nvp_data = be64dec(ptr); else nvp->nvp_data = le64dec(ptr); ptr += sizeof(uint64_t); *leftp -= sizeof(uint64_t); return (ptr); } const unsigned char * nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp) { PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING); if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) { errno = EINVAL; return (NULL); } if (strnlen((const char *)ptr, nvp->nvp_datasize) != nvp->nvp_datasize - 1) { errno = EINVAL; return (NULL); } nvp->nvp_data = (uint64_t)(uintptr_t)strdup((const char *)ptr); if (nvp->nvp_data == 0) return (NULL); ptr += nvp->nvp_datasize; *leftp -= nvp->nvp_datasize; return (ptr); } const unsigned char * nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp, size_t nfds, nvlist_t **child) { nvlist_t *value; PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST); if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) { errno = EINVAL; return (NULL); } value = nvlist_create(0); if (value == NULL) return (NULL); ptr = nvlist_unpack_header(value, ptr, nfds, NULL, leftp); if (ptr == NULL) return (NULL); nvp->nvp_data = (uint64_t)(uintptr_t)value; *child = value; return (ptr); } const unsigned char * nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds) { int64_t idx; PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR); if (nvp->nvp_datasize != sizeof(idx)) { errno = EINVAL; return (NULL); } if (*leftp < sizeof(idx)) { errno = EINVAL; return (NULL); } if (isbe) idx = be64dec(ptr); else idx = le64dec(ptr); if (idx < 0) { errno = EINVAL; return (NULL); } if ((size_t)idx >= nfds) { errno = EINVAL; return (NULL); } nvp->nvp_data = (uint64_t)fds[idx]; ptr += sizeof(idx); *leftp -= sizeof(idx); return (ptr); } const unsigned char * nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr, size_t *leftp) { void *value; PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY); if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) { errno = EINVAL; return (NULL); } value = malloc(nvp->nvp_datasize); if (value == NULL) return (NULL); memcpy(value, ptr, nvp->nvp_datasize); ptr += nvp->nvp_datasize; *leftp -= nvp->nvp_datasize; nvp->nvp_data = (uint64_t)(uintptr_t)value; return (ptr); } const unsigned char * nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp, nvpair_t **nvpp) { nvpair_t *nvp, *tmp; nvp = calloc(1, sizeof(*nvp) + NV_NAME_MAX); if (nvp == NULL) return (NULL); nvp->nvp_name = (char *)(nvp + 1); ptr = nvpair_unpack_header(isbe, nvp, ptr, leftp); if (ptr == NULL) goto failed; tmp = realloc(nvp, sizeof(*nvp) + strlen(nvp->nvp_name) + 1); if (tmp == NULL) goto failed; nvp = tmp; /* Update nvp_name after realloc(). */ nvp->nvp_name = (char *)(nvp + 1); nvp->nvp_data = 0x00; nvp->nvp_magic = NVPAIR_MAGIC; *nvpp = nvp; return (ptr); failed: free(nvp); return (NULL); } int nvpair_type(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); return (nvp->nvp_type); } const char * nvpair_name(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); return (nvp->nvp_name); } static nvpair_t * nvpair_allocv(int type, uint64_t data, size_t datasize, const char *namefmt, va_list nameap) { nvpair_t *nvp; char *name; int namelen; PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST); namelen = vasprintf(&name, namefmt, nameap); if (namelen < 0) return (NULL); PJDLOG_ASSERT(namelen > 0); if (namelen >= NV_NAME_MAX) { free(name); errno = ENAMETOOLONG; return (NULL); } nvp = calloc(1, sizeof(*nvp) + namelen + 1); if (nvp != NULL) { nvp->nvp_name = (char *)(nvp + 1); memcpy(nvp->nvp_name, name, namelen + 1); nvp->nvp_type = type; nvp->nvp_data = data; nvp->nvp_datasize = datasize; nvp->nvp_magic = NVPAIR_MAGIC; } free(name); return (nvp); }; nvpair_t * nvpair_create_null(const char *name) { return (nvpair_createf_null("%s", name)); } nvpair_t * nvpair_create_bool(const char *name, bool value) { return (nvpair_createf_bool(value, "%s", name)); } nvpair_t * nvpair_create_number(const char *name, uint64_t value) { return (nvpair_createf_number(value, "%s", name)); } nvpair_t * nvpair_create_string(const char *name, const char *value) { return (nvpair_createf_string(value, "%s", name)); } nvpair_t * nvpair_create_stringf(const char *name, const char *valuefmt, ...) { va_list valueap; nvpair_t *nvp; va_start(valueap, valuefmt); nvp = nvpair_create_stringv(name, valuefmt, valueap); va_end(valueap); return (nvp); } nvpair_t * nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap) { nvpair_t *nvp; char *str; int len; len = vasprintf(&str, valuefmt, valueap); if (len < 0) return (NULL); nvp = nvpair_create_string(name, str); if (nvp == NULL) free(str); return (nvp); } nvpair_t * nvpair_create_nvlist(const char *name, const nvlist_t *value) { return (nvpair_createf_nvlist(value, "%s", name)); } nvpair_t * nvpair_create_descriptor(const char *name, int value) { return (nvpair_createf_descriptor(value, "%s", name)); } nvpair_t * nvpair_create_binary(const char *name, const void *value, size_t size) { return (nvpair_createf_binary(value, size, "%s", name)); } nvpair_t * nvpair_createf_null(const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_null(namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createf_bool(bool value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_bool(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createf_number(uint64_t value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_number(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createf_string(const char *value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_string(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createf_nvlist(const nvlist_t *value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_nvlist(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createf_descriptor(int value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_descriptor(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createf_binary(const void *value, size_t size, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_createv_binary(value, size, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_createv_null(const char *namefmt, va_list nameap) { return (nvpair_allocv(NV_TYPE_NULL, 0, 0, namefmt, nameap)); } nvpair_t * nvpair_createv_bool(bool value, const char *namefmt, va_list nameap) { return (nvpair_allocv(NV_TYPE_BOOL, value ? 1 : 0, sizeof(uint8_t), namefmt, nameap)); } nvpair_t * nvpair_createv_number(uint64_t value, const char *namefmt, va_list nameap) { return (nvpair_allocv(NV_TYPE_NUMBER, value, sizeof(value), namefmt, nameap)); } nvpair_t * nvpair_createv_string(const char *value, const char *namefmt, va_list nameap) { nvpair_t *nvp; size_t size; char *data; if (value == NULL) { errno = EINVAL; return (NULL); } data = strdup(value); if (data == NULL) return (NULL); size = strlen(value) + 1; nvp = nvpair_allocv(NV_TYPE_STRING, (uint64_t)(uintptr_t)data, size, namefmt, nameap); if (nvp == NULL) free(data); return (nvp); } nvpair_t * nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt, va_list nameap) { nvlist_t *nvl; nvpair_t *nvp; if (value == NULL) { errno = EINVAL; return (NULL); } nvl = nvlist_clone(value); if (nvl == NULL) return (NULL); nvp = nvpair_allocv(NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0, namefmt, nameap); if (nvp == NULL) nvlist_destroy(nvl); else nvlist_set_parent(nvl, nvp); return (nvp); } nvpair_t * nvpair_createv_descriptor(int value, const char *namefmt, va_list nameap) { nvpair_t *nvp; if (value < 0 || !fd_is_valid(value)) { errno = EBADF; return (NULL); } value = fcntl(value, F_DUPFD_CLOEXEC, 0); if (value < 0) return (NULL); nvp = nvpair_allocv(NV_TYPE_DESCRIPTOR, (uint64_t)value, sizeof(int64_t), namefmt, nameap); if (nvp == NULL) close(value); return (nvp); } nvpair_t * nvpair_createv_binary(const void *value, size_t size, const char *namefmt, va_list nameap) { nvpair_t *nvp; void *data; if (value == NULL || size == 0) { errno = EINVAL; return (NULL); } data = malloc(size); if (data == NULL) return (NULL); memcpy(data, value, size); nvp = nvpair_allocv(NV_TYPE_BINARY, (uint64_t)(uintptr_t)data, size, namefmt, nameap); if (nvp == NULL) free(data); return (nvp); } nvpair_t * nvpair_move_string(const char *name, char *value) { return (nvpair_movef_string(value, "%s", name)); } nvpair_t * nvpair_move_nvlist(const char *name, nvlist_t *value) { return (nvpair_movef_nvlist(value, "%s", name)); } nvpair_t * nvpair_move_descriptor(const char *name, int value) { return (nvpair_movef_descriptor(value, "%s", name)); } nvpair_t * nvpair_move_binary(const char *name, void *value, size_t size) { return (nvpair_movef_binary(value, size, "%s", name)); } nvpair_t * nvpair_movef_string(char *value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_movev_string(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_movef_nvlist(nvlist_t *value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_movev_nvlist(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_movef_descriptor(int value, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_movev_descriptor(value, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_movef_binary(void *value, size_t size, const char *namefmt, ...) { va_list nameap; nvpair_t *nvp; va_start(nameap, namefmt); nvp = nvpair_movev_binary(value, size, namefmt, nameap); va_end(nameap); return (nvp); } nvpair_t * nvpair_movev_string(char *value, const char *namefmt, va_list nameap) { nvpair_t *nvp; int serrno; if (value == NULL) { errno = EINVAL; return (NULL); } nvp = nvpair_allocv(NV_TYPE_STRING, (uint64_t)(uintptr_t)value, strlen(value) + 1, namefmt, nameap); if (nvp == NULL) { serrno = errno; free(value); errno = serrno; } return (nvp); } nvpair_t * nvpair_movev_nvlist(nvlist_t *value, const char *namefmt, va_list nameap) { nvpair_t *nvp; if (value == NULL || nvlist_get_nvpair_parent(value) != NULL) { errno = EINVAL; return (NULL); } + if (nvlist_error(value) != 0) { + errno = nvlist_error(value); + nvlist_destroy(value); + return (NULL); + } + nvp = nvpair_allocv(NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value, 0, namefmt, nameap); if (nvp == NULL) nvlist_destroy(value); else nvlist_set_parent(value, nvp); return (nvp); } nvpair_t * nvpair_movev_descriptor(int value, const char *namefmt, va_list nameap) { nvpair_t *nvp; int serrno; if (value < 0 || !fd_is_valid(value)) { errno = EBADF; return (NULL); } nvp = nvpair_allocv(NV_TYPE_DESCRIPTOR, (uint64_t)value, sizeof(int64_t), namefmt, nameap); if (nvp == NULL) { serrno = errno; close(value); errno = serrno; } return (nvp); } nvpair_t * nvpair_movev_binary(void *value, size_t size, const char *namefmt, va_list nameap) { nvpair_t *nvp; int serrno; if (value == NULL || size == 0) { errno = EINVAL; return (NULL); } nvp = nvpair_allocv(NV_TYPE_BINARY, (uint64_t)(uintptr_t)value, size, namefmt, nameap); if (nvp == NULL) { serrno = errno; free(value); errno = serrno; } return (nvp); } bool nvpair_get_bool(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); return (nvp->nvp_data == 1); } uint64_t nvpair_get_number(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); return (nvp->nvp_data); } const char * nvpair_get_string(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING); return ((const char *)(intptr_t)nvp->nvp_data); } const nvlist_t * nvpair_get_nvlist(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST); return ((const nvlist_t *)(intptr_t)nvp->nvp_data); } int nvpair_get_descriptor(const nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR); return ((int)nvp->nvp_data); } const void * nvpair_get_binary(const nvpair_t *nvp, size_t *sizep) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY); if (sizep != NULL) *sizep = nvp->nvp_datasize; return ((const void *)(intptr_t)nvp->nvp_data); } void nvpair_free(nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_list == NULL); nvp->nvp_magic = 0; switch (nvp->nvp_type) { case NV_TYPE_DESCRIPTOR: close((int)nvp->nvp_data); break; case NV_TYPE_NVLIST: nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data); break; case NV_TYPE_STRING: free((char *)(intptr_t)nvp->nvp_data); break; case NV_TYPE_BINARY: free((void *)(intptr_t)nvp->nvp_data); break; } free(nvp); } void nvpair_free_structure(nvpair_t *nvp) { NVPAIR_ASSERT(nvp); PJDLOG_ASSERT(nvp->nvp_list == NULL); nvp->nvp_magic = 0; free(nvp); } const char * nvpair_type_string(int type) { switch (type) { case NV_TYPE_NULL: return ("NULL"); case NV_TYPE_BOOL: return ("BOOL"); case NV_TYPE_NUMBER: return ("NUMBER"); case NV_TYPE_STRING: return ("STRING"); case NV_TYPE_NVLIST: return ("NVLIST"); case NV_TYPE_DESCRIPTOR: return ("DESCRIPTOR"); case NV_TYPE_BINARY: return ("BINARY"); default: return (""); } } Index: head/lib/libnv/tests/nv_tests.cc =================================================================== --- head/lib/libnv/tests/nv_tests.cc (revision 279435) +++ head/lib/libnv/tests/nv_tests.cc (revision 279436) @@ -1,2997 +1,3030 @@ /*- * Copyright (c) 2014-2015 Sandvine Inc. All rights reserved. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include /* * Test that a newly created nvlist has no errors, and is empty. */ ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty); ATF_TEST_CASE_BODY(nvlist_create__is_empty) { nvlist_t *nvl; int type; void *it; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE_EQ(nvlist_error(nvl), 0); ATF_REQUIRE(nvlist_empty(nvl)); it = NULL; ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert); ATF_TEST_CASE_BODY(nvlist_add_null__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "key"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(nvl, key); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_null(nvl, key)); ATF_REQUIRE(nvlist_existsf_null(nvl, "key")); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NULL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert); ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "name"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_bool(nvl, key, true); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me")); ATF_REQUIRE(nvlist_exists_bool(nvl, key)); ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e')); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true); ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert); ATF_TEST_CASE_BODY(nvlist_add_number__single_insert) { nvlist_t *nvl; void *it; const char *key; uint64_t value; int type; key = "foo123"; value = 71965; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_number(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123)); ATF_REQUIRE(nvlist_exists_number(nvl, key)); ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key)); ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value); ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert); ATF_TEST_CASE_BODY(nvlist_add_string__single_insert) { nvlist_t *nvl; void *it; const char *key; const char *value; int type; key = "test"; value = "fgjdkgjdk"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_string(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_string(nvl, key)); ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0); ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(nvlist_get_string(nvl, key) != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert); ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert) { nvlist_t *nvl; void *it; const char *key, *subkey; nvlist_t *sublist; const nvlist_t *value; int type; key = "test"; subkey = "subkey"; sublist = nvlist_create(0); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(sublist, subkey); nvlist_add_nvlist(nvl, key, sublist); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key)); value = nvlist_get_nvlist(nvl, key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(sublist != value); value = nvlist_getf_nvlist(nvl, "%s", key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); ATF_REQUIRE(sublist != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(sublist); nvlist_destroy(nvl); } +ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__child_with_error); +ATF_TEST_CASE_BODY(nvlist_add_nvlist__child_with_error) +{ + nvlist_t *nvl, *parent; + + nvl = nvlist_create(0); + parent = nvlist_create(0); + + nvlist_set_error(nvl, EBADF); + nvlist_add_nvlist(parent, "test", nvl); + ATF_REQUIRE_EQ(nvlist_error(parent), EBADF); + + nvlist_destroy(nvl); + nvlist_destroy(parent); +} + ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert); ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert) { nvlist_t *nvl; void *it; const char *key; void *value; const void *ret_value; size_t value_size, ret_size; int type; key = "binary"; value_size = 13; value = malloc(value_size); memset(value, 0xa5, value_size); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_binary(nvl, key, value, value_size); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_binary(nvl, key)); ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key)); ret_value = nvlist_get_binary(nvl, key, &ret_size); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(value != ret_value); ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); ATF_REQUIRE(value != ret_value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); free(value); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist) { nvlist_t *nvl, *clone; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); clone = nvlist_clone(nvl); ATF_REQUIRE(clone != NULL); ATF_REQUIRE(clone != nvl); ATF_REQUIRE(nvlist_empty(clone)); nvlist_destroy(clone); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist) { nvlist_t *nvl, *clone; const char *key; void *it; uint64_t value; int type; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; value = 684874; nvlist_add_number(nvl, key, value); clone = nvlist_clone(nvl); ATF_REQUIRE(clone != NULL); ATF_REQUIRE(clone != nvl); ATF_REQUIRE(nvlist_exists_number(clone, key)); ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), NULL); nvlist_destroy(clone); nvlist_destroy(nvl); } static const char * const test_subnvlist_key = "nvlist"; static const char * const test_string_key = "string"; static const char * const test_string_val = "59525"; static nvlist_t* create_test_nvlist(void) { nvlist_t *nvl, *sublist; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); sublist = nvlist_create(0); ATF_REQUIRE(sublist != NULL); nvlist_add_string(sublist, test_string_key, test_string_val); nvlist_move_nvlist(nvl, test_subnvlist_key, sublist); return (nvl); } static void verify_test_nvlist(const nvlist_t *nvl) { void *it; const nvlist_t *value; int type; ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key)); value = nvlist_get_nvlist(nvl, test_subnvlist_key); ATF_REQUIRE(nvlist_exists_string(value, test_string_key)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0); ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val); /* Iterate over both nvlists; ensure that each has only the one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it), test_string_key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), NULL); it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), test_subnvlist_key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist) { nvlist_t *nvl, *clone; nvl = create_test_nvlist(); clone = nvlist_clone(nvl); ATF_REQUIRE(clone != NULL); ATF_REQUIRE(clone != nvl); verify_test_nvlist(clone); nvlist_destroy(clone); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__error_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__error_nvlist) { nvlist_t *nvl, *clone; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); nvlist_set_error(nvl, ENOMEM); clone = nvlist_clone(nvl); ATF_REQUIRE(clone == NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist); ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist) { nvlist_t *nvl, *unpacked; void *packed; size_t packed_size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); packed = nvlist_pack(nvl, &packed_size); ATF_REQUIRE(packed != NULL); unpacked = nvlist_unpack(packed, packed_size); ATF_REQUIRE(unpacked != NULL); ATF_REQUIRE(unpacked != nvl); ATF_REQUIRE(nvlist_empty(unpacked)); nvlist_destroy(unpacked); nvlist_destroy(nvl); free(packed); } static void verify_null(const nvlist_t *nvl, int type) { ATF_REQUIRE_EQ(type, NV_TYPE_NULL); } static void verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value) { ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value); } static void verify_string(const nvlist_t *nvl, const char *name, int type, const char * value) { ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0); } static void verify_nvlist(const nvlist_t *nvl, const char *name, int type) { ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); verify_test_nvlist(nvlist_get_nvlist(nvl, name)); } static void verify_binary(const nvlist_t *nvl, const char *name, int type, const void * value, size_t size) { const void *actual_value; size_t actual_size; ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); actual_value = nvlist_get_binary(nvl, name, &actual_size); ATF_REQUIRE_EQ(size, actual_size); ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values); ATF_TEST_CASE_BODY(nvlist_pack__multiple_values) { std::ostringstream msg; std::set keys_seen; nvlist_t *nvl, *unpacked, *nvvalue; const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name; int numvalue; const char * strvalue; void *binvalue, *packed, *it; size_t binsize, packed_size; int type; nvl = nvlist_create(0); nullkey = "null"; nvlist_add_null(nvl, nullkey); numkey = "number"; numvalue = 939853984; nvlist_add_number(nvl, numkey, numvalue); strkey = "string"; strvalue = "jfieutijf"; nvlist_add_string(nvl, strkey, strvalue); nvkey = "nvlist"; nvvalue = create_test_nvlist(); nvlist_move_nvlist(nvl, nvkey, nvvalue); binkey = "binary"; binsize = 4; binvalue = malloc(binsize); memset(binvalue, 'b', binsize); nvlist_move_binary(nvl, binkey, binvalue, binsize); packed = nvlist_pack(nvl, &packed_size); ATF_REQUIRE(packed != NULL); unpacked = nvlist_unpack(packed, packed_size); ATF_REQUIRE(unpacked != 0); it = NULL; while ((name = nvlist_next(unpacked, &type, &it)) != NULL) { /* Ensure that we see every key only once. */ ATF_REQUIRE_EQ(keys_seen.count(name), 0); if (strcmp(name, nullkey) == 0) verify_null(unpacked, type); else if (strcmp(name, numkey) == 0) verify_number(unpacked, name, type, numvalue); else if (strcmp(name, strkey) == 0) verify_string(unpacked, name, type, strvalue); else if (strcmp(name, nvkey) == 0) verify_nvlist(unpacked, name, type); else if (strcmp(name, binkey) == 0) verify_binary(unpacked, name, type, binvalue, binsize); else { msg << "Unexpected key :'" << name << "'"; ATF_FAIL(msg.str().c_str()); } keys_seen.insert(name); } /* Ensure that we saw every key. */ ATF_REQUIRE_EQ(keys_seen.size(), 5); nvlist_destroy(nvl); nvlist_destroy(unpacked); free(packed); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__error_nvlist); ATF_TEST_CASE_BODY(nvlist_pack__error_nvlist) { nvlist_t *nvl; void *packed; size_t size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); nvlist_set_error(nvl, ENOMEM); packed = nvlist_pack(nvl, &size); ATF_REQUIRE(packed == NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key); ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key) { nvlist_t *nvl, *unpacked; const char *key1, *key2; void *packed, *keypos; size_t size, keylen; nvl = nvlist_create(0); key1 = "key1"; keylen = strlen(key1); nvlist_add_number(nvl, key1, 5); key2 = "key2"; ATF_REQUIRE_EQ(keylen, strlen(key2)); nvlist_add_number(nvl, key2, 10); packed = nvlist_pack(nvl, &size); /* * Mangle the packed nvlist by replacing key1 with key2, creating a * packed nvlist with a duplicate key. */ keypos = memmem(packed, size, key1, keylen); ATF_REQUIRE(keypos != NULL); memcpy(keypos, key2, keylen); unpacked = nvlist_unpack(packed, size); ATF_REQUIRE(nvlist_error(unpacked) != 0); free(packed); nvlist_destroy(nvl); nvlist_destroy(unpacked); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert); ATF_TEST_CASE_BODY(nvlist_move_string__single_insert) { nvlist_t *nvl; const char *key; char *value; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; value = strdup("testval"); ATF_REQUIRE(value != NULL); nvlist_move_string(nvl, key, value); ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child); ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child) { nvlist_t *parent; parent = nvlist_create(0); nvlist_move_nvlist(parent, "test", NULL); ATF_REQUIRE(nvlist_error(parent) != 0); nvlist_destroy(parent); } +ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__child_with_error); +ATF_TEST_CASE_BODY(nvlist_move_nvlist__child_with_error) +{ + nvlist_t *nvl, *parent; + + nvl = nvlist_create(0); + parent = nvlist_create(0); + + nvlist_set_error(nvl, EBADF); + nvlist_move_nvlist(parent, "test", nvl); + ATF_REQUIRE_EQ(nvlist_error(parent), EBADF); + + nvlist_destroy(parent); +} + ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert); ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert) { nvlist_t *nvl; const char *key; nvlist_t *value; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; value = nvlist_create(0); ATF_REQUIRE(value != NULL); nvlist_move_nvlist(nvl, key, value); ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert); ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert) { nvlist_t *nvl; const char *key; void *value; size_t size, actual_size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; size = 73; value = malloc(size); ATF_REQUIRE(value != NULL); nvlist_move_binary(nvl, key, value, size); ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value); ATF_REQUIRE_EQ(size, actual_size); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove); ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove) { nvlist_t *nvl; const char *testkey; bool testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "boolkey"; testval = false; nvlist_add_bool(nvl, testkey, testval); ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; bool testval, otherval1; nvlist_t *otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "boolkey"; testval = true; nvlist_add_bool(nvl, testkey, testval); otherkey1 = "key1"; otherval1 = false; nvlist_add_bool(nvl, otherkey1, otherval1); otherkey2 = "key2"; otherval2 = create_test_nvlist(); nvlist_move_nvlist(nvl, otherkey2, otherval2); ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval); ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1)); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1); ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2)); verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove); ATF_TEST_CASE_BODY(nvlist_take_number__single_remove) { nvlist_t *nvl; const char *testkey; uint64_t testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testval = std::numeric_limits::max(); nvlist_add_number(nvl, testkey, testval); ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; uint64_t testval, otherval1; const char *otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); otherkey1 = "key1"; otherval1 = 5; nvlist_add_number(nvl, otherkey1, otherval1); testkey = "numkey"; testval = 1654; nvlist_add_number(nvl, testkey, testval); otherkey2 = "key2"; otherval2 = "string"; nvlist_add_string(nvl, otherkey2, otherval2); ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval); ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1)); ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1); ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove); ATF_TEST_CASE_BODY(nvlist_take_string__single_remove) { nvlist_t *nvl; const char *testkey; const char *testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testval = "nvlist"; nvlist_add_string(nvl, testkey, testval); ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; const char *testval, *otherval1; bool otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); otherkey1 = "key1"; otherval1 = "fjdifjdk"; nvlist_add_string(nvl, otherkey1, otherval1); otherkey2 = "key2"; otherval2 = true; nvlist_add_bool(nvl, otherkey2, otherval2); testkey = "strkey"; testval = "1654"; nvlist_add_string(nvl, testkey, testval); ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0); ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0); ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2)); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove); ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove) { nvlist_t *nvl; const char *testkey; nvlist_t *testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testval = create_test_nvlist(); nvlist_move_nvlist(nvl, testkey, testval); verify_test_nvlist(nvlist_take_nvlist(nvl, testkey)); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; nvlist_t *testval, *otherval1; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "strkey"; testval = create_test_nvlist(); nvlist_move_nvlist(nvl, testkey, testval); otherkey1 = "key1"; otherval1 = nvlist_create(0); nvlist_move_nvlist(nvl, otherkey1, otherval1); otherkey2 = "key2"; nvlist_add_null(nvl, otherkey2); verify_test_nvlist(nvlist_take_nvlist(nvl, testkey)); ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1)); ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1))); ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove); ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove) { nvlist_t *nvl; const char *testkey; void *testval; const void *actual_val; size_t testsize, actual_size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testsize = 457; testval = malloc(testsize); memset(testval, '5', testsize); nvlist_move_binary(nvl, testkey, testval, testsize); actual_val = nvlist_take_binary(nvl, testkey, &actual_size); ATF_REQUIRE_EQ(testsize, actual_size); ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; const void *actual_value; char testval[] = "gjiertj"; char otherval1[] = "fdreg"; size_t testsize, othersize, actual_size; bool otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); otherkey1 = "key1"; othersize = sizeof(otherval1); nvlist_add_binary(nvl, otherkey1, otherval1, othersize); otherkey2 = "key2"; otherval2 = true; nvlist_add_bool(nvl, otherkey2, otherval2); testkey = "strkey"; testsize = sizeof(testval); nvlist_add_binary(nvl, testkey, testval, testsize); actual_value = nvlist_take_binary(nvl, testkey, &actual_size); ATF_REQUIRE_EQ(testsize, actual_size); ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0); ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1)); actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size); ATF_REQUIRE_EQ(othersize, actual_size); ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0); ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2)); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null); ATF_TEST_CASE_BODY(nvlist_free__single_null) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_null(nvl, key); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool); ATF_TEST_CASE_BODY(nvlist_free__single_bool) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_bool(nvl, key, true); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number); ATF_TEST_CASE_BODY(nvlist_free__single_number) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_number(nvl, key, 584); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string); ATF_TEST_CASE_BODY(nvlist_free__single_string) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_string(nvl, key, "gjkfkjd"); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist); ATF_TEST_CASE_BODY(nvlist_free__single_nvlist) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_nvlist(nvl, key, nvlist_create(0)); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary); ATF_TEST_CASE_BODY(nvlist_free__single_binary) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_binary(nvl, key, "jgjgfd", 6); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null); ATF_TEST_CASE_BODY(nvlist_free_null__single_null) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_null(nvl, key); nvlist_free_null(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool); ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_bool(nvl, key, true); nvlist_free_bool(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number); ATF_TEST_CASE_BODY(nvlist_free_number__single_number) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_number(nvl, key, 584); nvlist_free_number(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string); ATF_TEST_CASE_BODY(nvlist_free_string__single_string) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_string(nvl, key, "gjkfkjd"); nvlist_free_string(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist); ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_nvlist(nvl, key, nvlist_create(0)); nvlist_free_nvlist(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary); ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_binary(nvl, key, "jgjgfd", 6); nvlist_free_binary(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_INIT_TEST_CASES(tp) { ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty); ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert); + ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__child_with_error); ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values); ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key); ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child); + ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__child_with_error); ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_free__single_null); ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool); ATF_ADD_TEST_CASE(tp, nvlist_free__single_number); ATF_ADD_TEST_CASE(tp, nvlist_free__single_string); ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary); ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null); ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool); ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number); ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string); ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary); } /*- * Copyright (c) 2014-2015 Sandvine Inc. All rights reserved. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include /* * Test that a newly created nvlist has no errors, and is empty. */ ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty); ATF_TEST_CASE_BODY(nvlist_create__is_empty) { nvlist_t *nvl; int type; void *it; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE_EQ(nvlist_error(nvl), 0); ATF_REQUIRE(nvlist_empty(nvl)); it = NULL; ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert); ATF_TEST_CASE_BODY(nvlist_add_null__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "key"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(nvl, key); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_null(nvl, key)); ATF_REQUIRE(nvlist_existsf_null(nvl, "key")); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NULL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert); ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "name"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_bool(nvl, key, true); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me")); ATF_REQUIRE(nvlist_exists_bool(nvl, key)); ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e')); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true); ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert); ATF_TEST_CASE_BODY(nvlist_add_number__single_insert) { nvlist_t *nvl; void *it; const char *key; uint64_t value; int type; key = "foo123"; value = 71965; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_number(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123)); ATF_REQUIRE(nvlist_exists_number(nvl, key)); ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key)); ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value); ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert); ATF_TEST_CASE_BODY(nvlist_add_string__single_insert) { nvlist_t *nvl; void *it; const char *key; const char *value; int type; key = "test"; value = "fgjdkgjdk"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_string(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_string(nvl, key)); ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0); ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(nvlist_get_string(nvl, key) != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert); ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert) { nvlist_t *nvl; void *it; const char *key, *subkey; nvlist_t *sublist; const nvlist_t *value; int type; key = "test"; subkey = "subkey"; sublist = nvlist_create(0); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(sublist, subkey); nvlist_add_nvlist(nvl, key, sublist); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key)); value = nvlist_get_nvlist(nvl, key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(sublist != value); value = nvlist_getf_nvlist(nvl, "%s", key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); ATF_REQUIRE(sublist != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(sublist); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert); ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert) { nvlist_t *nvl; void *it; const char *key; void *value; const void *ret_value; size_t value_size, ret_size; int type; key = "binary"; value_size = 13; value = malloc(value_size); memset(value, 0xa5, value_size); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_binary(nvl, key, value, value_size); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_binary(nvl, key)); ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key)); ret_value = nvlist_get_binary(nvl, key, &ret_size); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(value != ret_value); ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); ATF_REQUIRE(value != ret_value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); free(value); } ATF_INIT_TEST_CASES(tp) { ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty); ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert); } /*- * Copyright (c) 2014-2015 Sandvine Inc. All rights reserved. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include /* * Test that a newly created nvlist has no errors, and is empty. */ ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty); ATF_TEST_CASE_BODY(nvlist_create__is_empty) { nvlist_t *nvl; int type; void *it; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE_EQ(nvlist_error(nvl), 0); ATF_REQUIRE(nvlist_empty(nvl)); it = NULL; ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert); ATF_TEST_CASE_BODY(nvlist_add_null__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "key"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(nvl, key); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_null(nvl, key)); ATF_REQUIRE(nvlist_existsf_null(nvl, "key")); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NULL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert); ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "name"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_bool(nvl, key, true); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me")); ATF_REQUIRE(nvlist_exists_bool(nvl, key)); ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e')); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true); ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert); ATF_TEST_CASE_BODY(nvlist_add_number__single_insert) { nvlist_t *nvl; void *it; const char *key; uint64_t value; int type; key = "foo123"; value = 71965; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_number(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123)); ATF_REQUIRE(nvlist_exists_number(nvl, key)); ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key)); ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value); ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert); ATF_TEST_CASE_BODY(nvlist_add_string__single_insert) { nvlist_t *nvl; void *it; const char *key; const char *value; int type; key = "test"; value = "fgjdkgjdk"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_string(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_string(nvl, key)); ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0); ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(nvlist_get_string(nvl, key) != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert); ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert) { nvlist_t *nvl; void *it; const char *key, *subkey; nvlist_t *sublist; const nvlist_t *value; int type; key = "test"; subkey = "subkey"; sublist = nvlist_create(0); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(sublist, subkey); nvlist_add_nvlist(nvl, key, sublist); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key)); value = nvlist_get_nvlist(nvl, key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(sublist != value); value = nvlist_getf_nvlist(nvl, "%s", key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); ATF_REQUIRE(sublist != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(sublist); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert); ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert) { nvlist_t *nvl; void *it; const char *key; void *value; const void *ret_value; size_t value_size, ret_size; int type; key = "binary"; value_size = 13; value = malloc(value_size); memset(value, 0xa5, value_size); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_binary(nvl, key, value, value_size); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_binary(nvl, key)); ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key)); ret_value = nvlist_get_binary(nvl, key, &ret_size); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(value != ret_value); ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); ATF_REQUIRE(value != ret_value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); free(value); } ATF_INIT_TEST_CASES(tp) { ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty); ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert); } /*- * Copyright (c) 2014-2015 Sandvine Inc. All rights reserved. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include /* * Test that a newly created nvlist has no errors, and is empty. */ ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty); ATF_TEST_CASE_BODY(nvlist_create__is_empty) { nvlist_t *nvl; int type; void *it; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE_EQ(nvlist_error(nvl), 0); ATF_REQUIRE(nvlist_empty(nvl)); it = NULL; ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert); ATF_TEST_CASE_BODY(nvlist_add_null__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "key"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(nvl, key); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_null(nvl, key)); ATF_REQUIRE(nvlist_existsf_null(nvl, "key")); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NULL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert); ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert) { nvlist_t *nvl; void *it; const char *key; int type; key = "name"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_bool(nvl, key, true); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me")); ATF_REQUIRE(nvlist_exists_bool(nvl, key)); ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e')); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true); ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BOOL); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert); ATF_TEST_CASE_BODY(nvlist_add_number__single_insert) { nvlist_t *nvl; void *it; const char *key; uint64_t value; int type; key = "foo123"; value = 71965; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_number(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123)); ATF_REQUIRE(nvlist_exists_number(nvl, key)); ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key)); ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value); ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert); ATF_TEST_CASE_BODY(nvlist_add_string__single_insert) { nvlist_t *nvl; void *it; const char *key; const char *value; int type; key = "test"; value = "fgjdkgjdk"; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_string(nvl, key, value); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_string(nvl, key)); ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0); ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(nvlist_get_string(nvl, key) != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert); ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert) { nvlist_t *nvl; void *it; const char *key, *subkey; nvlist_t *sublist; const nvlist_t *value; int type; key = "test"; subkey = "subkey"; sublist = nvlist_create(0); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_null(sublist, subkey); nvlist_add_nvlist(nvl, key, sublist); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_nvlist(nvl, key)); ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key)); value = nvlist_get_nvlist(nvl, key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(sublist != value); value = nvlist_getf_nvlist(nvl, "%s", key); ATF_REQUIRE(nvlist_exists_null(value, subkey)); ATF_REQUIRE(sublist != value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(sublist); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert); ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert) { nvlist_t *nvl; void *it; const char *key; void *value; const void *ret_value; size_t value_size, ret_size; int type; key = "binary"; value_size = 13; value = malloc(value_size); memset(value, 0xa5, value_size); nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); ATF_REQUIRE(!nvlist_exists(nvl, key)); nvlist_add_binary(nvl, key, value, value_size); ATF_REQUIRE(!nvlist_empty(nvl)); ATF_REQUIRE(nvlist_exists(nvl, key)); ATF_REQUIRE(nvlist_existsf(nvl, "%s", key)); ATF_REQUIRE(nvlist_exists_binary(nvl, key)); ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key)); ret_value = nvlist_get_binary(nvl, key, &ret_size); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); /* nvlist_add_* is required to clone the value, so check for that. */ ATF_REQUIRE(value != ret_value); ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key); ATF_REQUIRE_EQ(value_size, ret_size); ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0); ATF_REQUIRE(value != ret_value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), NULL); nvlist_destroy(nvl); free(value); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist) { nvlist_t *nvl, *clone; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); clone = nvlist_clone(nvl); ATF_REQUIRE(clone != NULL); ATF_REQUIRE(clone != nvl); ATF_REQUIRE(nvlist_empty(clone)); nvlist_destroy(clone); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist) { nvlist_t *nvl, *clone; const char *key; void *it; uint64_t value; int type; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; value = 684874; nvlist_add_number(nvl, key, value); clone = nvlist_clone(nvl); ATF_REQUIRE(clone != NULL); ATF_REQUIRE(clone != nvl); ATF_REQUIRE(nvlist_exists_number(clone, key)); ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value); /* Iterate over the nvlist; ensure that it has only our one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), NULL); nvlist_destroy(clone); nvlist_destroy(nvl); } static const char * const test_subnvlist_key = "nvlist"; static const char * const test_string_key = "string"; static const char * const test_string_val = "59525"; static nvlist_t* create_test_nvlist(void) { nvlist_t *nvl, *sublist; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); sublist = nvlist_create(0); ATF_REQUIRE(sublist != NULL); nvlist_add_string(sublist, test_string_key, test_string_val); nvlist_move_nvlist(nvl, test_subnvlist_key, sublist); return (nvl); } static void verify_test_nvlist(const nvlist_t *nvl) { void *it; const nvlist_t *value; int type; ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key)); value = nvlist_get_nvlist(nvl, test_subnvlist_key); ATF_REQUIRE(nvlist_exists_string(value, test_string_key)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0); ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val); /* Iterate over both nvlists; ensure that each has only the one key. */ it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it), test_string_key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), NULL); it = NULL; ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), test_subnvlist_key), 0); ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), NULL); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist); ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist) { nvlist_t *nvl, *clone; nvl = create_test_nvlist(); clone = nvlist_clone(nvl); ATF_REQUIRE(clone != NULL); ATF_REQUIRE(clone != nvl); verify_test_nvlist(clone); nvlist_destroy(clone); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist); ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist) { nvlist_t *nvl, *unpacked; void *packed; size_t packed_size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); packed = nvlist_pack(nvl, &packed_size); ATF_REQUIRE(packed != NULL); unpacked = nvlist_unpack(packed, packed_size); ATF_REQUIRE(unpacked != NULL); ATF_REQUIRE(unpacked != nvl); ATF_REQUIRE(nvlist_empty(unpacked)); nvlist_destroy(unpacked); nvlist_destroy(nvl); free(packed); } static void verify_null(const nvlist_t *nvl, int type) { ATF_REQUIRE_EQ(type, NV_TYPE_NULL); } static void verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value) { ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER); ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value); } static void verify_string(const nvlist_t *nvl, const char *name, int type, const char * value) { ATF_REQUIRE_EQ(type, NV_TYPE_STRING); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0); } static void verify_nvlist(const nvlist_t *nvl, const char *name, int type) { ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST); verify_test_nvlist(nvlist_get_nvlist(nvl, name)); } static void verify_binary(const nvlist_t *nvl, const char *name, int type, const void * value, size_t size) { const void *actual_value; size_t actual_size; ATF_REQUIRE_EQ(type, NV_TYPE_BINARY); actual_value = nvlist_get_binary(nvl, name, &actual_size); ATF_REQUIRE_EQ(size, actual_size); ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values); ATF_TEST_CASE_BODY(nvlist_pack__multiple_values) { std::ostringstream msg; std::set keys_seen; nvlist_t *nvl, *unpacked, *nvvalue; const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name; int numvalue; const char * strvalue; void *binvalue, *packed, *it; size_t binsize, packed_size; int type; nvl = nvlist_create(0); nullkey = "null"; nvlist_add_null(nvl, nullkey); numkey = "number"; numvalue = 939853984; nvlist_add_number(nvl, numkey, numvalue); strkey = "string"; strvalue = "jfieutijf"; nvlist_add_string(nvl, strkey, strvalue); nvkey = "nvlist"; nvvalue = create_test_nvlist(); nvlist_move_nvlist(nvl, nvkey, nvvalue); binkey = "binary"; binsize = 4; binvalue = malloc(binsize); memset(binvalue, 'b', binsize); nvlist_move_binary(nvl, binkey, binvalue, binsize); packed = nvlist_pack(nvl, &packed_size); ATF_REQUIRE(packed != NULL); unpacked = nvlist_unpack(packed, packed_size); ATF_REQUIRE(unpacked != 0); it = NULL; while ((name = nvlist_next(unpacked, &type, &it)) != NULL) { /* Ensure that we see every key only once. */ ATF_REQUIRE_EQ(keys_seen.count(name), 0); if (strcmp(name, nullkey) == 0) verify_null(unpacked, type); else if (strcmp(name, numkey) == 0) verify_number(unpacked, name, type, numvalue); else if (strcmp(name, strkey) == 0) verify_string(unpacked, name, type, strvalue); else if (strcmp(name, nvkey) == 0) verify_nvlist(unpacked, name, type); else if (strcmp(name, binkey) == 0) verify_binary(unpacked, name, type, binvalue, binsize); else { msg << "Unexpected key :'" << name << "'"; ATF_FAIL(msg.str().c_str()); } keys_seen.insert(name); } /* Ensure that we saw every key. */ ATF_REQUIRE_EQ(keys_seen.size(), 5); nvlist_destroy(nvl); nvlist_destroy(unpacked); free(packed); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key); ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key) { nvlist_t *nvl, *unpacked; const char *key1, *key2; void *packed, *keypos; size_t size, keylen; nvl = nvlist_create(0); key1 = "key1"; keylen = strlen(key1); nvlist_add_number(nvl, key1, 5); key2 = "key2"; ATF_REQUIRE_EQ(keylen, strlen(key2)); nvlist_add_number(nvl, key2, 10); packed = nvlist_pack(nvl, &size); /* * Mangle the packed nvlist by replacing key1 with key2, creating a * packed nvlist with a duplicate key. */ keypos = memmem(packed, size, key1, keylen); ATF_REQUIRE(keypos != NULL); memcpy(keypos, key2, keylen); unpacked = nvlist_unpack(packed, size); ATF_REQUIRE(nvlist_error(unpacked) != 0); free(packed); nvlist_destroy(nvl); nvlist_destroy(unpacked); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert); ATF_TEST_CASE_BODY(nvlist_move_string__single_insert) { nvlist_t *nvl; const char *key; char *value; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; value = strdup("testval"); ATF_REQUIRE(value != NULL); nvlist_move_string(nvl, key, value); ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child); ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child) { nvlist_t *parent; parent = nvlist_create(0); nvlist_move_nvlist(parent, "test", NULL); ATF_REQUIRE(nvlist_error(parent) != 0); nvlist_destroy(parent); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert); ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert) { nvlist_t *nvl; const char *key; nvlist_t *value; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; value = nvlist_create(0); ATF_REQUIRE(value != NULL); nvlist_move_nvlist(nvl, key, value); ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert); ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert) { nvlist_t *nvl; const char *key; void *value; size_t size, actual_size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); key = "testkey"; size = 73; value = malloc(size); ATF_REQUIRE(value != NULL); nvlist_move_binary(nvl, key, value, size); ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value); ATF_REQUIRE_EQ(size, actual_size); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove); ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove) { nvlist_t *nvl; const char *testkey; bool testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "boolkey"; testval = false; nvlist_add_bool(nvl, testkey, testval); ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; bool testval, otherval1; nvlist_t *otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "boolkey"; testval = true; nvlist_add_bool(nvl, testkey, testval); otherkey1 = "key1"; otherval1 = false; nvlist_add_bool(nvl, otherkey1, otherval1); otherkey2 = "key2"; otherval2 = create_test_nvlist(); nvlist_move_nvlist(nvl, otherkey2, otherval2); ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval); ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1)); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1); ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2)); verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove); ATF_TEST_CASE_BODY(nvlist_take_number__single_remove) { nvlist_t *nvl; const char *testkey; uint64_t testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testval = std::numeric_limits::max(); nvlist_add_number(nvl, testkey, testval); ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; uint64_t testval, otherval1; const char *otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); otherkey1 = "key1"; otherval1 = 5; nvlist_add_number(nvl, otherkey1, otherval1); testkey = "numkey"; testval = 1654; nvlist_add_number(nvl, testkey, testval); otherkey2 = "key2"; otherval2 = "string"; nvlist_add_string(nvl, otherkey2, otherval2); ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval); ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1)); ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1); ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove); ATF_TEST_CASE_BODY(nvlist_take_string__single_remove) { nvlist_t *nvl; const char *testkey; const char *testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testval = "nvlist"; nvlist_add_string(nvl, testkey, testval); ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; const char *testval, *otherval1; bool otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); otherkey1 = "key1"; otherval1 = "fjdifjdk"; nvlist_add_string(nvl, otherkey1, otherval1); otherkey2 = "key2"; otherval2 = true; nvlist_add_bool(nvl, otherkey2, otherval2); testkey = "strkey"; testval = "1654"; nvlist_add_string(nvl, testkey, testval); ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0); ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1)); ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0); ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2)); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove); ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove) { nvlist_t *nvl; const char *testkey; nvlist_t *testval; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testval = create_test_nvlist(); nvlist_move_nvlist(nvl, testkey, testval); verify_test_nvlist(nvlist_take_nvlist(nvl, testkey)); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; nvlist_t *testval, *otherval1; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "strkey"; testval = create_test_nvlist(); nvlist_move_nvlist(nvl, testkey, testval); otherkey1 = "key1"; otherval1 = nvlist_create(0); nvlist_move_nvlist(nvl, otherkey1, otherval1); otherkey2 = "key2"; nvlist_add_null(nvl, otherkey2); verify_test_nvlist(nvlist_take_nvlist(nvl, testkey)); ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1)); ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1))); ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove); ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove) { nvlist_t *nvl; const char *testkey; void *testval; const void *actual_val; size_t testsize, actual_size; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); testkey = "numkey"; testsize = 457; testval = malloc(testsize); memset(testval, '5', testsize); nvlist_move_binary(nvl, testkey, testval, testsize); actual_val = nvlist_take_binary(nvl, testkey, &actual_size); ATF_REQUIRE_EQ(testsize, actual_size); ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged); ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged) { nvlist_t *nvl; const char *testkey, *otherkey1, *otherkey2; const void *actual_value; char testval[] = "gjiertj"; char otherval1[] = "fdreg"; size_t testsize, othersize, actual_size; bool otherval2; nvl = nvlist_create(0); ATF_REQUIRE(nvl != NULL); otherkey1 = "key1"; othersize = sizeof(otherval1); nvlist_add_binary(nvl, otherkey1, otherval1, othersize); otherkey2 = "key2"; otherval2 = true; nvlist_add_bool(nvl, otherkey2, otherval2); testkey = "strkey"; testsize = sizeof(testval); nvlist_add_binary(nvl, testkey, testval, testsize); actual_value = nvlist_take_binary(nvl, testkey, &actual_size); ATF_REQUIRE_EQ(testsize, actual_size); ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0); ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1)); actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size); ATF_REQUIRE_EQ(othersize, actual_size); ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0); ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2)); ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null); ATF_TEST_CASE_BODY(nvlist_free__single_null) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_null(nvl, key); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool); ATF_TEST_CASE_BODY(nvlist_free__single_bool) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_bool(nvl, key, true); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number); ATF_TEST_CASE_BODY(nvlist_free__single_number) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_number(nvl, key, 584); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string); ATF_TEST_CASE_BODY(nvlist_free__single_string) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_string(nvl, key, "gjkfkjd"); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist); ATF_TEST_CASE_BODY(nvlist_free__single_nvlist) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_nvlist(nvl, key, nvlist_create(0)); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary); ATF_TEST_CASE_BODY(nvlist_free__single_binary) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_binary(nvl, key, "jgjgfd", 6); nvlist_free(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null); ATF_TEST_CASE_BODY(nvlist_free_null__single_null) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_null(nvl, key); nvlist_free_null(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool); ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_bool(nvl, key, true); nvlist_free_bool(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number); ATF_TEST_CASE_BODY(nvlist_free_number__single_number) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_number(nvl, key, 584); nvlist_free_number(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string); ATF_TEST_CASE_BODY(nvlist_free_string__single_string) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_string(nvl, key, "gjkfkjd"); nvlist_free_string(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist); ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_nvlist(nvl, key, nvlist_create(0)); nvlist_free_nvlist(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary); ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary) { nvlist_t *nvl; const char *key; nvl = nvlist_create(0); key = "test"; nvlist_add_binary(nvl, key, "jgjgfd", 6); nvlist_free_binary(nvl, key); ATF_REQUIRE(nvlist_empty(nvl)); nvlist_destroy(nvl); } ATF_INIT_TEST_CASES(tp) { ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty); ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values); ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key); ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child); ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert); ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove); ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged); ATF_ADD_TEST_CASE(tp, nvlist_free__single_null); ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool); ATF_ADD_TEST_CASE(tp, nvlist_free__single_number); ATF_ADD_TEST_CASE(tp, nvlist_free__single_string); ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary); ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null); ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool); ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number); ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string); ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist); ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary); }