/* $NetBSD: t_proplib.c,v 1.5 2025/09/23 22:35:40 rillig Exp $ */

/*
 * Copyright (c) 2008, 2020 The NetBSD Foundation, Inc.
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * Written by Jason Thorpe 5/26/2006.
 * Public domain.
 */

#include <sys/cdefs.h>
__COPYRIGHT("@(#) Copyright (c) 2008, 2020\
 The NetBSD Foundation, inc. All rights reserved.");
__RCSID("$NetBSD: t_proplib.c,v 1.5 2025/09/23 22:35:40 rillig Exp $");

#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <prop/proplib.h>

#include <atf-c.h>

static const char compare1[] =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
"<plist version=\"1.0\">\n"
"<dict>\n"
"       <key>false-val</key>\n"
"       <false/>\n"
"       <key>one</key>\n"
"       <integer>1</integer>\n"
"       <key>three</key>\n"
"       <array>\n"
"               <dict>\n"
"                       <key>one</key>\n"
"                       <integer>1</integer>\n"
"                       <key>two</key>\n"
"                       <string>number-two</string>\n"
"               </dict>\n"
"               <dict>\n"
"                       <key>one</key>\n"
"                       <integer>1</integer>\n"
"                       <key>two</key>\n"
"                       <string>number-two</string>\n"
"               </dict>\n"
"               <dict>\n"
"                       <key>one</key>\n"
"                       <integer>1</integer>\n"
"                       <key>two</key>\n"
"                       <string>number-two</string>\n"
"               </dict>\n"
"       </array>\n"
"       <key>true-val</key>\n"
"       <true/>\n"
"       <key>two</key>\n"
"       <string>number-two</string>\n"
"</dict>\n"
"</plist>\n";

static const char const_data1[] = {
        0xde, 0xad, 0xbe, 0xef
};

static const char const_data2[] = {
        0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55
};

static const char const_string1[] =
    "The quick brown fox jumps over the lazy dog.";

static const char const_string2[] =
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, "
    "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";

ATF_TC(prop_basic);
ATF_TC_HEAD(prop_basic, tc)
{
        atf_tc_set_md_var(tc, "descr", "A basic test of proplib(3)");
}

ATF_TC_BODY(prop_basic, tc)
{
        prop_dictionary_t dict;
        char *ext1;

        dict = prop_dictionary_create();
        ATF_REQUIRE(dict != NULL);

        {
                prop_number_t num = prop_number_create_signed(1);
                ATF_REQUIRE(num != NULL);

                ATF_REQUIRE_EQ(prop_dictionary_set(dict, "one", num), true);
                prop_object_release(num);
        }

        {
                prop_string_t str = prop_string_create_copy("number-two");
                ATF_REQUIRE(str != NULL);

                ATF_REQUIRE_EQ(prop_dictionary_set(dict, "two", str), true);
                prop_object_release(str);
        }

        {
                prop_array_t arr;
                prop_dictionary_t dict_copy;
                int i;

                arr = prop_array_create();
                ATF_REQUIRE(arr != NULL);

                for (i = 0; i < 3; ++i) {
                        dict_copy = prop_dictionary_copy(dict);
                        ATF_REQUIRE(dict_copy != NULL);
                        ATF_REQUIRE_EQ(prop_array_add(arr, dict_copy), true);
                        prop_object_release(dict_copy);
                }

                ATF_REQUIRE_EQ(prop_dictionary_set(dict, "three", arr), true);
                prop_object_release(arr);
        }

        {
                prop_bool_t val = prop_bool_create(true);
                ATF_REQUIRE(val != NULL);
                ATF_REQUIRE_EQ(prop_dictionary_set(dict, "true-val", val), true);
                prop_object_release(val);

                val = prop_bool_create(false);
                ATF_REQUIRE(val != NULL);
                ATF_REQUIRE_EQ(prop_dictionary_set(dict, "false-val", val), true);
                prop_object_release(val);
        }

        ext1 = prop_dictionary_externalize(dict);
        ATF_REQUIRE(ext1 != NULL);
        ATF_REQUIRE_STREQ(compare1, ext1);

        {
                prop_dictionary_t dict2;
                char *ext2;

                dict2 = prop_dictionary_internalize(ext1);
                ATF_REQUIRE(dict2 != NULL);
                ext2 = prop_dictionary_externalize(dict2);
                ATF_REQUIRE(ext2 != NULL);
                ATF_REQUIRE_STREQ(ext1, ext2);
                prop_object_release(dict2);
                free(ext2);
        }

        prop_object_release(dict);
        free(ext1);
}

ATF_TC(prop_dictionary_equals);
ATF_TC_HEAD(prop_dictionary_equals, tc)
{
        atf_tc_set_md_var(tc, "descr", "Test prop_dictionary_equals(3)");
}

ATF_TC_BODY(prop_dictionary_equals, tc)
{
        prop_dictionary_t c, d;

        /*
         * Fixed, should not fail any more...
         *
        atf_tc_expect_death("PR lib/43964");
         *
         */

        d = prop_dictionary_internalize(compare1);

        ATF_REQUIRE(d != NULL);

        c = prop_dictionary_copy(d);

        ATF_REQUIRE(c != NULL);

        if (prop_dictionary_equals(c, d) != true)
                atf_tc_fail("dictionaries are not equal");

        prop_object_release(c);
        prop_object_release(d);
}

ATF_TC(prop_dictionary_internalize_base64);
ATF_TC_HEAD(prop_dictionary_internalize_base64, tc)
{
        atf_tc_set_md_var(tc, "descr", "Test internalizing base64-encoded data");
}

ATF_TC_BODY(prop_dictionary_internalize_base64, tc)
{

        prop_dictionary_t dict = prop_dictionary_internalize(
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
"<plist version=\"1.0\">\n"
"<dict>\n"
"       <key>encoded</key>\n"
"       <data>SGVsbG8sIHdvcmxkCg==</data>\n"
"       <key>length-1</key>\n"
"       <data>aQ==</data>\n"
"       <key>length-2</key>\n"
"       <data>aWk=</data>\n"
"       <key>length-3</key>\n"
"       <data>aWlp</data>\n"
"</dict>\n"
"</plist>\n");


        ATF_REQUIRE(dict != NULL);

        const void *data;
        size_t size;
        bool ok;

        ok = prop_dictionary_get_data(dict, "encoded", &data, &size);
        ATF_REQUIRE(ok);
        ATF_CHECK_EQ(size, 13);
        ATF_CHECK_EQ(memcmp(data, "Hello, world\n", 13), 0);

        ok = prop_dictionary_get_data(dict, "length-1", &data, &size);
        ATF_REQUIRE(ok);
        ATF_CHECK_EQ(size, 1);
        ATF_CHECK_EQ(memcmp(data, "i", 1), 0);

        ok = prop_dictionary_get_data(dict, "length-2", &data, &size);
        ATF_REQUIRE(ok);
        ATF_CHECK_EQ(size, 2);
        ATF_CHECK_EQ(memcmp(data, "ii", 2), 0);

        ok = prop_dictionary_get_data(dict, "length-3", &data, &size);
        ATF_REQUIRE(ok);
        ATF_CHECK_EQ(size, 3);
        ATF_CHECK_EQ(memcmp(data, "iii", 3), 0);

        prop_object_release(dict);
}

ATF_TC(prop_data_basic);
ATF_TC_HEAD(prop_data_basic, tc)
{
        atf_tc_set_md_var(tc, "descr", "tests prop_data basics");
}
ATF_TC_BODY(prop_data_basic, tc)
{
        prop_data_t d1, d2;
        char buf[sizeof(const_data1)];

        /*
         * This test exercises implementation details, not only
         * API contract.
         */

        d1 = prop_data_create_copy(const_data1, 0);
        ATF_REQUIRE(d1 != NULL);
        ATF_REQUIRE(prop_data_value(d1) == NULL);
        prop_object_release(d1);

        d1 = prop_data_create_copy(NULL, sizeof(const_data1));
        ATF_REQUIRE(d1 != NULL);
        ATF_REQUIRE(prop_data_value(d1) == NULL);
        prop_object_release(d1);

        d1 = prop_data_create_nocopy(const_data1, 0);
        ATF_REQUIRE(d1 != NULL);
        ATF_REQUIRE(prop_data_value(d1) == NULL);
        prop_object_release(d1);

        d1 = prop_data_create_nocopy(NULL, sizeof(const_data1));
        ATF_REQUIRE(d1 != NULL);
        ATF_REQUIRE(prop_data_value(d1) == NULL);
        prop_object_release(d1);

        d1 = prop_data_create_nocopy(const_data1, sizeof(const_data1));
        ATF_REQUIRE(d1 != NULL);
        ATF_REQUIRE(prop_data_value(d1) == const_data1);
        d2 = prop_data_copy(d1);
        ATF_REQUIRE(d2 != NULL);
        ATF_REQUIRE(d2 == d1);
        prop_object_release(d1);
        prop_object_release(d2);

        d1 = prop_data_create_copy(const_data1, sizeof(const_data1));
        ATF_REQUIRE(d1 != NULL);
        ATF_REQUIRE(prop_data_value(d1) != const_data1);
        d2 = prop_data_copy(d1);
        ATF_REQUIRE(d2 != NULL);
        ATF_REQUIRE(d2 == d1);
        ATF_REQUIRE(prop_data_equals(d1, d2));
        prop_object_release(d2);

        d2 = prop_data_create_copy(const_data2, sizeof(const_data2));
        ATF_REQUIRE(d2 != NULL);
        ATF_REQUIRE(prop_data_value(d2) != const_data2);
        ATF_REQUIRE(!prop_data_equals(d1, d2));

        ATF_REQUIRE(prop_data_size(d1) == sizeof(const_data1));
        ATF_REQUIRE(prop_data_size(d2) == sizeof(const_data2));

        ATF_REQUIRE(prop_data_copy_value(d1, buf, sizeof(buf)));
        ATF_REQUIRE(memcmp(buf, const_data1, sizeof(buf)) == 0);
        ATF_REQUIRE(!prop_data_copy_value(d2, buf, sizeof(buf)));

        prop_object_release(d1);
        prop_object_release(d2);
}

ATF_TC(prop_number_basic);
ATF_TC_HEAD(prop_number_basic, tc)
{
        atf_tc_set_md_var(tc, "descr", "tests prop_number basics");
}
ATF_TC_BODY(prop_number_basic, tc)
{
        prop_number_t s1, s2, u1, u2, u3, u4;

        /*
         * This test exercises implementation details, not only
         * API contract.
         */

        s1 = prop_number_create_signed(INTMAX_MAX);
        ATF_REQUIRE(s1 != NULL);
        ATF_REQUIRE(prop_number_unsigned(s1) == false);
        ATF_REQUIRE(prop_number_signed_value(s1) == INTMAX_MAX);
        ATF_REQUIRE(prop_number_unsigned_value(s1) == INTMAX_MAX);
        ATF_REQUIRE(prop_number_equals_signed(s1, INTMAX_MAX) == true);

        s2 = prop_number_create_signed(INTMAX_MAX);
        ATF_REQUIRE(s2 == s1);
        ATF_REQUIRE(prop_number_unsigned(s2) == false);

        u1 = prop_number_create_unsigned(UINTMAX_MAX);
        ATF_REQUIRE(u1 != NULL);
        ATF_REQUIRE(prop_number_unsigned(u1) == true);
        ATF_REQUIRE(prop_number_unsigned_value(u1) == UINTMAX_MAX);
        ATF_REQUIRE(prop_number_equals_unsigned(u1, UINTMAX_MAX) == true);

        u2 = prop_number_create_unsigned(0);
        ATF_REQUIRE(u2 != NULL);
        ATF_REQUIRE(u2 != u1);
        ATF_REQUIRE(prop_number_unsigned(u2) == true);
        ATF_REQUIRE(prop_number_unsigned_value(u2) == 0);

        u3 = prop_number_copy(u1);
        ATF_REQUIRE(u3 == u1);
        ATF_REQUIRE(prop_number_unsigned(u3) == true);
        ATF_REQUIRE(prop_number_unsigned_value(u3) == UINTMAX_MAX);

        u4 = prop_number_create_unsigned(INTMAX_MAX);
        ATF_REQUIRE(u4 != NULL);
        ATF_REQUIRE(u4 != s1);
        ATF_REQUIRE(prop_number_equals_signed(u4, INTMAX_MAX) == true);
        ATF_REQUIRE(prop_number_equals_unsigned(u4, INTMAX_MAX) == true);

        prop_object_release(s1);
        prop_object_release(s2);

        prop_object_release(u1);
        prop_object_release(u2);
        prop_object_release(u3);
        prop_object_release(u4);
}

ATF_TC(prop_number_range_check);
ATF_TC_HEAD(prop_number_range_check, tc)
{
        atf_tc_set_md_var(tc, "descr", "tests prop_number range checking");
}
ATF_TC_BODY(prop_number_range_check, tc)
{
        union {
                signed char v_schar;
                short v_shrt;
                int v_int;
                long v_long;
                long long v_llong;
                intptr_t v_intptr;
                int8_t v_int8;
                int16_t v_int16;
                int32_t v_int32;
                int64_t v_int64;

                unsigned char v_uchar;
                unsigned short v_ushrt;
                unsigned int v_uint;
                unsigned long v_ulong;
                unsigned long long v_ullong;
                uintptr_t v_uintptr;
                uint8_t v_uint8;
                uint16_t v_uint16;
                uint32_t v_uint32;
                uint64_t v_uint64;
        } val;

        prop_number_t n_schar_max = prop_number_create_signed(SCHAR_MAX);
        prop_number_t n_schar_min = prop_number_create_signed(SCHAR_MIN);
        prop_number_t n_uchar_max = prop_number_create_unsigned(UCHAR_MAX);
        ATF_REQUIRE(n_schar_max != NULL);
        ATF_REQUIRE(n_schar_min != NULL);
        ATF_REQUIRE(n_uchar_max != NULL);

        prop_number_t n_shrt_max = prop_number_create_signed(SHRT_MAX);
        prop_number_t n_shrt_min = prop_number_create_signed(SHRT_MIN);
        prop_number_t n_ushrt_max = prop_number_create_unsigned(USHRT_MAX);
        ATF_REQUIRE(n_shrt_max != NULL);
        ATF_REQUIRE(n_shrt_min != NULL);
        ATF_REQUIRE(n_ushrt_max != NULL);

        prop_number_t n_int_max = prop_number_create_signed(INT_MAX);
        prop_number_t n_int_min = prop_number_create_signed(INT_MIN);
        prop_number_t n_uint_max = prop_number_create_unsigned(UINT_MAX);
        ATF_REQUIRE(n_int_max != NULL);
        ATF_REQUIRE(n_int_min != NULL);
        ATF_REQUIRE(n_uint_max != NULL);

        prop_number_t n_long_max = prop_number_create_signed(LONG_MAX);
        prop_number_t n_long_min = prop_number_create_signed(LONG_MIN);
        prop_number_t n_ulong_max = prop_number_create_unsigned(ULONG_MAX);
        ATF_REQUIRE(n_long_max != NULL);
        ATF_REQUIRE(n_long_min != NULL);
        ATF_REQUIRE(n_ulong_max != NULL);

        prop_number_t n_llong_max = prop_number_create_signed(LLONG_MAX);
        prop_number_t n_llong_min = prop_number_create_signed(LLONG_MIN);
        prop_number_t n_ullong_max = prop_number_create_unsigned(ULLONG_MAX);
        ATF_REQUIRE(n_llong_max != NULL);
        ATF_REQUIRE(n_llong_min != NULL);
        ATF_REQUIRE(n_ullong_max != NULL);

        prop_number_t n_intptr_max = prop_number_create_signed(INTPTR_MAX);
        prop_number_t n_intptr_min = prop_number_create_signed(INTPTR_MIN);
        prop_number_t n_uintptr_max = prop_number_create_unsigned(UINTPTR_MAX);
        ATF_REQUIRE(n_intptr_max != NULL);
        ATF_REQUIRE(n_intptr_min != NULL);
        ATF_REQUIRE(n_uintptr_max != NULL);

        prop_number_t n_int8_max = prop_number_create_signed(INT8_MAX);
        prop_number_t n_int8_min = prop_number_create_signed(INT8_MIN);
        prop_number_t n_uint8_max = prop_number_create_unsigned(UINT8_MAX);
        ATF_REQUIRE(n_int8_max != NULL);
        ATF_REQUIRE(n_int8_min != NULL);
        ATF_REQUIRE(n_uint8_max != NULL);

        prop_number_t n_int16_max = prop_number_create_signed(INT16_MAX);
        prop_number_t n_int16_min = prop_number_create_signed(INT16_MIN);
        prop_number_t n_uint16_max = prop_number_create_unsigned(UINT16_MAX);
        ATF_REQUIRE(n_int16_max != NULL);
        ATF_REQUIRE(n_int16_min != NULL);
        ATF_REQUIRE(n_uint16_max != NULL);

        prop_number_t n_int32_max = prop_number_create_signed(INT32_MAX);
        prop_number_t n_int32_min = prop_number_create_signed(INT32_MIN);
        prop_number_t n_uint32_max = prop_number_create_unsigned(UINT32_MAX);
        ATF_REQUIRE(n_int32_max != NULL);
        ATF_REQUIRE(n_int32_min != NULL);
        ATF_REQUIRE(n_uint32_max != NULL);

        prop_number_t n_int64_max = prop_number_create_signed(INT64_MAX);
        prop_number_t n_int64_min = prop_number_create_signed(INT64_MIN);
        prop_number_t n_uint64_max = prop_number_create_unsigned(UINT64_MAX);
        ATF_REQUIRE(n_int64_max != NULL);
        ATF_REQUIRE(n_int64_min != NULL);
        ATF_REQUIRE(n_uint64_max != NULL);

        /* signed / unsigned char */
        ATF_REQUIRE(prop_number_schar_value(n_schar_max, &val.v_schar) &&
                    val.v_schar == SCHAR_MAX);
        ATF_REQUIRE(prop_number_schar_value(n_schar_min, &val.v_schar) &&
                    val.v_schar == SCHAR_MIN);
        ATF_REQUIRE(!prop_number_schar_value(n_uchar_max, &val.v_schar));

        ATF_REQUIRE(prop_number_uchar_value(n_schar_max, &val.v_uchar) &&
                    val.v_uchar == SCHAR_MAX);
        ATF_REQUIRE(!prop_number_uchar_value(n_schar_min, &val.v_uchar));
        ATF_REQUIRE(prop_number_uchar_value(n_uchar_max, &val.v_uchar) &&
                    val.v_uchar == UCHAR_MAX);

        ATF_REQUIRE(!prop_number_schar_value(n_shrt_min, &val.v_schar));
        ATF_REQUIRE(!prop_number_uchar_value(n_shrt_max, &val.v_uchar));

        /* short / unsigned short */
        ATF_REQUIRE(prop_number_short_value(n_uchar_max, &val.v_shrt) &&
                    val.v_shrt == UCHAR_MAX);
        
        ATF_REQUIRE(prop_number_short_value(n_shrt_max, &val.v_shrt) &&
                    val.v_shrt == SHRT_MAX);
        ATF_REQUIRE(prop_number_short_value(n_shrt_min, &val.v_shrt) &&
                    val.v_shrt == SHRT_MIN);
        ATF_REQUIRE(!prop_number_short_value(n_ushrt_max, &val.v_shrt));

        ATF_REQUIRE(prop_number_ushort_value(n_shrt_max, &val.v_ushrt) &&
                    val.v_ushrt == SHRT_MAX);
        ATF_REQUIRE(!prop_number_ushort_value(n_shrt_min, &val.v_ushrt));
        ATF_REQUIRE(prop_number_ushort_value(n_ushrt_max, &val.v_ushrt) &&
                    val.v_ushrt == USHRT_MAX);

        ATF_REQUIRE(!prop_number_short_value(n_int_min, &val.v_shrt));
        ATF_REQUIRE(!prop_number_ushort_value(n_int_max, &val.v_ushrt));

        /* int / unsigned int */
        ATF_REQUIRE(prop_number_int_value(n_ushrt_max, &val.v_int) &&
                    val.v_int == USHRT_MAX);
        
        ATF_REQUIRE(prop_number_int_value(n_int_max, &val.v_int) &&
                    val.v_int == INT_MAX);
        ATF_REQUIRE(prop_number_int_value(n_int_min, &val.v_int) &&
                    val.v_int == INT_MIN);
        ATF_REQUIRE(!prop_number_int_value(n_uint_max, &val.v_int));

        ATF_REQUIRE(prop_number_uint_value(n_int_max, &val.v_uint) &&
                    val.v_uint == INT_MAX);
        ATF_REQUIRE(!prop_number_uint_value(n_int_min, &val.v_uint));
        ATF_REQUIRE(prop_number_uint_value(n_uint_max, &val.v_uint) &&
                    val.v_uint == UINT_MAX);

#ifdef _LP64
        ATF_REQUIRE(!prop_number_int_value(n_long_min, &val.v_int));
        ATF_REQUIRE(!prop_number_uint_value(n_long_max, &val.v_uint));
#else
        ATF_REQUIRE(!prop_number_int_value(n_llong_min, &val.v_int));
        ATF_REQUIRE(!prop_number_uint_value(n_llong_max, &val.v_uint));
#endif /* _LP64 */

        /* long / unsigned long */
#ifdef _LP64
        ATF_REQUIRE(prop_number_long_value(n_uint_max, &val.v_long) &&
                    val.v_long == UINT_MAX);
#endif

        ATF_REQUIRE(prop_number_long_value(n_long_max, &val.v_long) &&
                    val.v_long == LONG_MAX);
        ATF_REQUIRE(prop_number_long_value(n_long_min, &val.v_long) &&
                    val.v_long == LONG_MIN);
        ATF_REQUIRE(!prop_number_long_value(n_ulong_max, &val.v_long));

        ATF_REQUIRE(prop_number_ulong_value(n_long_max, &val.v_ulong) &&
                    val.v_ulong == LONG_MAX);
        ATF_REQUIRE(!prop_number_ulong_value(n_long_min, &val.v_ulong));
        ATF_REQUIRE(prop_number_ulong_value(n_ulong_max, &val.v_ulong) &&
                    val.v_ulong == ULONG_MAX);

#ifndef _LP64
        ATF_REQUIRE(!prop_number_long_value(n_llong_min, &val.v_long));
        ATF_REQUIRE(!prop_number_ulong_value(n_llong_max, &val.v_ulong));
#endif

        /* intptr_t / uintptr_t */
#ifdef _LP64
        ATF_REQUIRE(prop_number_intptr_value(n_uint_max, &val.v_intptr) &&
                    val.v_intptr == UINT_MAX);
#endif

        ATF_REQUIRE(prop_number_intptr_value(n_intptr_max, &val.v_intptr) &&
                    val.v_intptr == INTPTR_MAX);
        ATF_REQUIRE(prop_number_intptr_value(n_intptr_min, &val.v_intptr) &&
                    val.v_intptr == INTPTR_MIN);
        ATF_REQUIRE(!prop_number_intptr_value(n_uintptr_max, &val.v_intptr));

        ATF_REQUIRE(prop_number_uintptr_value(n_intptr_max, &val.v_uintptr) &&
                    val.v_uintptr == INTPTR_MAX);
        ATF_REQUIRE(!prop_number_uintptr_value(n_intptr_min, &val.v_uintptr));
        ATF_REQUIRE(prop_number_uintptr_value(n_uintptr_max, &val.v_uintptr) &&
                    val.v_uintptr == UINTPTR_MAX);

#ifndef _LP64
        ATF_REQUIRE(!prop_number_intptr_value(n_llong_min, &val.v_intptr));
        ATF_REQUIRE(!prop_number_uintptr_value(n_llong_max, &val.v_uintptr));
#endif

        /* long long / unsigned long long */
#ifdef _LP64
        ATF_REQUIRE(prop_number_longlong_value(n_uint_max, &val.v_llong) &&
                    val.v_llong == UINT_MAX);
#else
        ATF_REQUIRE(prop_number_longlong_value(n_ulong_max, &val.v_llong) &&
                    val.v_llong == ULONG_MAX);
#endif

        ATF_REQUIRE(prop_number_longlong_value(n_llong_max, &val.v_llong) &&
                    val.v_llong == LLONG_MAX);
        ATF_REQUIRE(prop_number_longlong_value(n_llong_min, &val.v_llong) &&
                    val.v_llong == LLONG_MIN);
        ATF_REQUIRE(!prop_number_longlong_value(n_ullong_max, &val.v_llong));

        ATF_REQUIRE(prop_number_ulonglong_value(n_llong_max, &val.v_ullong) &&
                    val.v_ullong == LLONG_MAX);
        ATF_REQUIRE(!prop_number_ulonglong_value(n_llong_min, &val.v_ullong));
        ATF_REQUIRE(prop_number_ulonglong_value(n_ullong_max, &val.v_ullong) &&
                    val.v_ullong == ULLONG_MAX);

        /* int8_t / uint8_t */
        ATF_REQUIRE(prop_number_int8_value(n_int8_max, &val.v_int8) &&
                    val.v_int8 == INT8_MAX);
        ATF_REQUIRE(prop_number_int8_value(n_int8_min, &val.v_int8) &&
                    val.v_int8 == INT8_MIN);
        ATF_REQUIRE(!prop_number_int8_value(n_uint8_max, &val.v_int8));

        ATF_REQUIRE(prop_number_uint8_value(n_int8_max, &val.v_uint8) &&
                    val.v_uint8 == INT8_MAX);
        ATF_REQUIRE(!prop_number_uint8_value(n_int8_min, &val.v_uint8));
        ATF_REQUIRE(prop_number_uint8_value(n_uint8_max, &val.v_uint8) &&
                    val.v_uint8 == UINT8_MAX);

        ATF_REQUIRE(!prop_number_int8_value(n_int16_min, &val.v_int8));
        ATF_REQUIRE(!prop_number_uint8_value(n_int16_max, &val.v_uint8));

        /* int16_t / uint16_t */
        ATF_REQUIRE(prop_number_int16_value(n_uint8_max, &val.v_int16) &&
                    val.v_int16 == UINT8_MAX);

        ATF_REQUIRE(prop_number_int16_value(n_int16_max, &val.v_int16) &&
                    val.v_int16 == INT16_MAX);
        ATF_REQUIRE(prop_number_int16_value(n_int16_min, &val.v_int16) &&
                    val.v_int16 == INT16_MIN);
        ATF_REQUIRE(!prop_number_int16_value(n_uint16_max, &val.v_int16));

        ATF_REQUIRE(prop_number_uint16_value(n_int16_max, &val.v_uint16) &&
                    val.v_uint16 == INT16_MAX);
        ATF_REQUIRE(!prop_number_uint16_value(n_int16_min, &val.v_uint16));
        ATF_REQUIRE(prop_number_uint16_value(n_uint16_max, &val.v_uint16) &&
                    val.v_uint16 == UINT16_MAX);

        ATF_REQUIRE(!prop_number_int16_value(n_int32_min, &val.v_int16));
        ATF_REQUIRE(!prop_number_uint16_value(n_int32_max, &val.v_uint16));

        /* int32_t / uint32_t */
        ATF_REQUIRE(prop_number_int32_value(n_uint16_max, &val.v_int32) &&
                    val.v_int32 == UINT16_MAX);

        ATF_REQUIRE(prop_number_int32_value(n_int32_max, &val.v_int32) &&
                    val.v_int32 == INT32_MAX);
        ATF_REQUIRE(prop_number_int32_value(n_int32_min, &val.v_int32) &&
                    val.v_int32 == INT32_MIN);
        ATF_REQUIRE(!prop_number_int32_value(n_uint32_max, &val.v_int32));

        ATF_REQUIRE(prop_number_uint32_value(n_int32_max, &val.v_uint32) &&
                    val.v_uint32 == INT32_MAX);
        ATF_REQUIRE(!prop_number_uint32_value(n_int32_min, &val.v_uint32));
        ATF_REQUIRE(prop_number_uint32_value(n_uint32_max, &val.v_uint32) &&
                    val.v_uint32 == UINT32_MAX);

        ATF_REQUIRE(!prop_number_int32_value(n_int64_min, &val.v_int32));
        ATF_REQUIRE(!prop_number_uint32_value(n_int64_max, &val.v_uint32));

        /* int64_t / uint64_t */
        ATF_REQUIRE(prop_number_int64_value(n_uint32_max, &val.v_int64) &&
                    val.v_int64 == UINT32_MAX);

        ATF_REQUIRE(prop_number_int64_value(n_int64_max, &val.v_int64) &&
                    val.v_int64 == INT64_MAX);
        ATF_REQUIRE(prop_number_int64_value(n_int64_min, &val.v_int64) &&
                    val.v_int64 == INT64_MIN);
        ATF_REQUIRE(!prop_number_int64_value(n_uint64_max, &val.v_int64));

        ATF_REQUIRE(prop_number_uint64_value(n_int64_max, &val.v_uint64) &&
                    val.v_uint64 == INT64_MAX);
        ATF_REQUIRE(!prop_number_uint64_value(n_int64_min, &val.v_uint64));
        ATF_REQUIRE(prop_number_uint64_value(n_uint64_max, &val.v_uint64) &&
                    val.v_uint64 == UINT64_MAX);

        prop_object_release(n_schar_max);
        prop_object_release(n_schar_min);
        prop_object_release(n_uchar_max);

        prop_object_release(n_shrt_max);
        prop_object_release(n_shrt_min);
        prop_object_release(n_ushrt_max);

        prop_object_release(n_int_max);
        prop_object_release(n_int_min);
        prop_object_release(n_uint_max);

        prop_object_release(n_long_max);
        prop_object_release(n_long_min);
        prop_object_release(n_ulong_max);

        prop_object_release(n_llong_max);
        prop_object_release(n_llong_min);
        prop_object_release(n_ullong_max);

        prop_object_release(n_intptr_max);
        prop_object_release(n_intptr_min);
        prop_object_release(n_uintptr_max);

        prop_object_release(n_int8_max);
        prop_object_release(n_int8_min);
        prop_object_release(n_uint8_max);

        prop_object_release(n_int16_max);
        prop_object_release(n_int16_min);
        prop_object_release(n_uint16_max);

        prop_object_release(n_int32_max);
        prop_object_release(n_int32_min);
        prop_object_release(n_uint32_max);

        prop_object_release(n_int64_max);
        prop_object_release(n_int64_min);
        prop_object_release(n_uint64_max);
}

ATF_TC(prop_string_basic);
ATF_TC_HEAD(prop_string_basic, tc)
{
        atf_tc_set_md_var(tc, "descr", "tests prop_string basics");
}
ATF_TC_BODY(prop_string_basic, tc)
{
        prop_string_t s1, s2, s3;
        prop_number_t num;
        char buf[sizeof(const_string1)];

        /*
         * This test exercises implementation details, not only
         * API contract.
         */

        s1 = prop_string_create_nocopy(const_string1);
        ATF_REQUIRE(s1 != NULL);
        s2 = prop_string_create_copy(const_string1);
        ATF_REQUIRE(s2 != NULL);
        ATF_REQUIRE(s2 == s1);
        ATF_REQUIRE(prop_string_value(s1) == const_string1);
        prop_object_release(s1);
        prop_object_release(s2);

        s1 = prop_string_create_copy(const_string1);
        ATF_REQUIRE(s1 != NULL);
        s2 = prop_string_create_nocopy(const_string1);
        ATF_REQUIRE(s2 != NULL);
        ATF_REQUIRE(s2 == s1);
        ATF_REQUIRE(prop_string_value(s1) != const_string1);
        prop_object_release(s1);
        prop_object_release(s2);

        s1 = prop_string_create_format("%d-%d", 12345, 67890);
        ATF_REQUIRE(s1 != NULL);
        ATF_REQUIRE(strcmp(prop_string_value(s1), "12345-67890") == 0);
        ATF_REQUIRE(prop_string_equals_string(s1, "12345-67890"));
        prop_object_release(s1);

        s1 = prop_string_create_nocopy(const_string1);
        ATF_REQUIRE(s1 != NULL);
        s2 = prop_string_create_nocopy(const_string2);
        ATF_REQUIRE(s2 != NULL);
        ATF_REQUIRE(prop_string_size(s1) == strlen(const_string1));
        ATF_REQUIRE(prop_string_size(s2) == strlen(const_string2));
        ATF_REQUIRE(prop_string_copy_value(s1, buf, sizeof(buf)));
        ATF_REQUIRE(!prop_string_copy_value(s2, buf, sizeof(buf)));
        prop_object_release(s1);
        prop_object_release(s2);

        s1 = prop_string_create_copy("a");
        ATF_REQUIRE(s1 != NULL);
        s2 = prop_string_create_copy("b");
        ATF_REQUIRE(s2 != NULL);
        s3 = prop_string_copy(s2);
        ATF_REQUIRE(s3 != NULL);
        ATF_REQUIRE(s3 == s2);
        num = prop_number_create_signed(666);
        ATF_REQUIRE(num != NULL);
        ATF_REQUIRE(!prop_string_equals(s1, s2));
        ATF_REQUIRE(prop_string_equals(s2, s3));
        ATF_REQUIRE(prop_string_compare(s1, s2) < 0);
        ATF_REQUIRE(prop_string_compare(s2, s1) > 0);
        ATF_REQUIRE(prop_string_compare(s2, s3) == 0);
        ATF_REQUIRE(prop_string_compare_string(s1, "b") < 0);
        ATF_REQUIRE(prop_string_compare_string(s2, "a") > 0);
        ATF_REQUIRE(prop_string_compare_string(s3, "b") == 0);
        ATF_REQUIRE(prop_string_compare(s1, (prop_string_t)num) != 0);
        ATF_REQUIRE(prop_string_compare((prop_string_t)num, s1) != 0);
        ATF_REQUIRE(prop_string_compare_string((prop_string_t)num, "666") != 0);
        prop_object_release(s1);
        prop_object_release(s2);
        prop_object_release(s3);
        prop_object_release(num);
}

ATF_TC(prop_dict_util);
ATF_TC_HEAD(prop_dict_util, tc)
{
        atf_tc_set_md_var(tc, "descr", "tests prop_dictionary_util basics");
}
ATF_TC_BODY(prop_dict_util, tc)
{
        union {
                signed char v_schar;
                short v_shrt;
                int v_int;
                long v_long;
                long long v_llong;
                intptr_t v_intptr;
                int8_t v_int8;
                int16_t v_int16;
                int32_t v_int32;
                int64_t v_int64;

                unsigned char v_uchar;
                unsigned short v_ushrt;
                unsigned int v_uint;
                unsigned long v_ulong;
                unsigned long long v_ullong;
                uintptr_t v_uintptr;
                uint8_t v_uint8;
                uint16_t v_uint16;
                uint32_t v_uint32;
                uint64_t v_uint64;
        } val;
        prop_dictionary_t dict;
        const char *cp;
        const void *v;
        size_t size;

        dict = prop_dictionary_create();
        ATF_REQUIRE(dict != NULL);

        ATF_REQUIRE(prop_dictionary_set_schar(dict, "schar", SCHAR_MIN));
        ATF_REQUIRE(prop_dictionary_get_schar(dict, "schar", &val.v_schar));
        ATF_REQUIRE(val.v_schar == SCHAR_MIN);

        ATF_REQUIRE(prop_dictionary_set_short(dict, "shrt", SHRT_MIN));
        ATF_REQUIRE(prop_dictionary_get_short(dict, "shrt", &val.v_shrt));
        ATF_REQUIRE(val.v_shrt == SHRT_MIN);

        ATF_REQUIRE(prop_dictionary_set_int(dict, "int", INT_MIN));
        ATF_REQUIRE(prop_dictionary_get_int(dict, "int", &val.v_int));
        ATF_REQUIRE(val.v_int == INT_MIN);

        ATF_REQUIRE(prop_dictionary_set_long(dict, "long", LONG_MIN));
        ATF_REQUIRE(prop_dictionary_get_long(dict, "long", &val.v_long));
        ATF_REQUIRE(val.v_long == LONG_MIN);

        ATF_REQUIRE(prop_dictionary_set_longlong(dict, "longlong", LLONG_MIN));
        ATF_REQUIRE(prop_dictionary_get_longlong(dict, "longlong",
                                                 &val.v_llong));
        ATF_REQUIRE(val.v_llong == LLONG_MIN);

        ATF_REQUIRE(prop_dictionary_set_intptr(dict, "intptr", INTPTR_MIN));
        ATF_REQUIRE(prop_dictionary_get_intptr(dict, "intptr", &val.v_intptr));
        ATF_REQUIRE(val.v_intptr == INTPTR_MIN);

        ATF_REQUIRE(prop_dictionary_set_int8(dict, "int8", INT8_MIN));
        ATF_REQUIRE(prop_dictionary_get_int8(dict, "int8", &val.v_int8));
        ATF_REQUIRE(val.v_int8 == INT8_MIN);

        ATF_REQUIRE(prop_dictionary_set_int16(dict, "int16", INT16_MIN));
        ATF_REQUIRE(prop_dictionary_get_int16(dict, "int16", &val.v_int16));
        ATF_REQUIRE(val.v_int16 == INT16_MIN);

        ATF_REQUIRE(prop_dictionary_set_int32(dict, "int32", INT32_MIN));
        ATF_REQUIRE(prop_dictionary_get_int32(dict, "int32", &val.v_int32));
        ATF_REQUIRE(val.v_int32 == INT32_MIN);

        ATF_REQUIRE(prop_dictionary_set_int64(dict, "int64", INT64_MIN));
        ATF_REQUIRE(prop_dictionary_get_int64(dict, "int64", &val.v_int64));
        ATF_REQUIRE(val.v_int64 == INT64_MIN);


        ATF_REQUIRE(prop_dictionary_set_uchar(dict, "uchar", UCHAR_MAX));
        ATF_REQUIRE(prop_dictionary_get_uchar(dict, "uchar", &val.v_uchar));
        ATF_REQUIRE(val.v_uchar == UCHAR_MAX);

        ATF_REQUIRE(prop_dictionary_set_ushort(dict, "ushrt", USHRT_MAX));
        ATF_REQUIRE(prop_dictionary_get_ushort(dict, "ushrt", &val.v_ushrt));
        ATF_REQUIRE(val.v_ushrt == USHRT_MAX);

        ATF_REQUIRE(prop_dictionary_set_uint(dict, "uint", UINT_MAX));
        ATF_REQUIRE(prop_dictionary_get_uint(dict, "uint", &val.v_uint));
        ATF_REQUIRE(val.v_uint == UINT_MAX);

        ATF_REQUIRE(prop_dictionary_set_ulong(dict, "ulong", ULONG_MAX));
        ATF_REQUIRE(prop_dictionary_get_ulong(dict, "ulong", &val.v_ulong));
        ATF_REQUIRE(val.v_ulong == ULONG_MAX);

        ATF_REQUIRE(prop_dictionary_set_ulonglong(dict, "ulonglong",
                                                  ULLONG_MAX));
        ATF_REQUIRE(prop_dictionary_get_ulonglong(dict, "ulonglong",
                                                  &val.v_ullong));
        ATF_REQUIRE(val.v_ullong == ULLONG_MAX);

        ATF_REQUIRE(prop_dictionary_set_uintptr(dict, "uintptr", UINTPTR_MAX));
        ATF_REQUIRE(prop_dictionary_get_uintptr(dict, "uintptr",
                                                &val.v_uintptr));
        ATF_REQUIRE(val.v_uintptr == UINTPTR_MAX);

        ATF_REQUIRE(prop_dictionary_set_uint8(dict, "uint8", UINT8_MAX));
        ATF_REQUIRE(prop_dictionary_get_uint8(dict, "uint8", &val.v_uint8));
        ATF_REQUIRE(val.v_uint8 == UINT8_MAX);

        ATF_REQUIRE(prop_dictionary_set_uint16(dict, "uint16", UINT16_MAX));
        ATF_REQUIRE(prop_dictionary_get_uint16(dict, "uint16", &val.v_uint16));
        ATF_REQUIRE(val.v_uint16 == UINT16_MAX);

        ATF_REQUIRE(prop_dictionary_set_uint32(dict, "uint32", UINT32_MAX));
        ATF_REQUIRE(prop_dictionary_get_uint32(dict, "uint32", &val.v_uint32));
        ATF_REQUIRE(val.v_uint32 == UINT32_MAX);

        ATF_REQUIRE(prop_dictionary_set_uint64(dict, "uint64", UINT64_MAX));
        ATF_REQUIRE(prop_dictionary_get_uint64(dict, "uint64", &val.v_uint64));
        ATF_REQUIRE(val.v_uint64 == UINT64_MAX);

        ATF_REQUIRE(prop_dictionary_set_string_nocopy(dict, "string",
                                                      const_string1));
        ATF_REQUIRE(prop_dictionary_get_string(dict, "string", &cp));
        ATF_REQUIRE(cp == const_string1);
        prop_dictionary_remove(dict, "string");

        ATF_REQUIRE(prop_dictionary_set_string(dict, "string", const_string1));
        ATF_REQUIRE(prop_dictionary_get_string(dict, "string", &cp));
        ATF_REQUIRE(cp != const_string1);
        ATF_REQUIRE(strcmp(cp, const_string1) == 0);

        ATF_REQUIRE(prop_dictionary_set_data_nocopy(dict, "data",
                                                    const_data1,
                                                    sizeof(const_data1)));
        ATF_REQUIRE(prop_dictionary_get_data(dict, "data", &v, NULL));
        ATF_REQUIRE(v == const_data1);
        prop_dictionary_remove(dict, "data");

        size = 0xdeadbeef;
        ATF_REQUIRE(prop_dictionary_set_data(dict, "data", const_data1,
                                             sizeof(const_data1)));
        ATF_REQUIRE(prop_dictionary_get_data(dict, "data", &v, &size));
        ATF_REQUIRE(v != const_data1);
        ATF_REQUIRE(size == sizeof(const_data1));
        ATF_REQUIRE(memcmp(v, const_data1, size) == 0);

        prop_object_release(dict);
}

ATF_TP_ADD_TCS(tp)
{

        ATF_TP_ADD_TC(tp, prop_basic);
        ATF_TP_ADD_TC(tp, prop_dictionary_equals);
        ATF_TP_ADD_TC(tp, prop_dictionary_internalize_base64);
        ATF_TP_ADD_TC(tp, prop_dict_util);
        ATF_TP_ADD_TC(tp, prop_data_basic);
        ATF_TP_ADD_TC(tp, prop_number_basic);
        ATF_TP_ADD_TC(tp, prop_number_range_check);
        ATF_TP_ADD_TC(tp, prop_string_basic);

        return atf_no_error();
}