From: dota17 Date: Thu, 20 Feb 2020 07:17:05 +0000 (+0800) Subject: add uint64 data to json-c X-Git-Tag: json-c-0.14-20200419~52^2~3 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=3c3b5920f77c751471cd46b92f9d3f5aa6ff2557;p=thirdparty%2Fjson-c.git add uint64 data to json-c --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 0008cbbe..2fce8699 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -142,6 +142,7 @@ endif() if (MSVC) check_symbol_exists(strtoll "stdlib.h" HAVE_STRTOLL) + check_symbol_exists(strtoull "stdlib.h" HAVE_STRTOULL) set(json_c_strtoll "strtoll") if (NOT HAVE_STRTOLL) @@ -153,6 +154,16 @@ if (MSVC) # could do the same for strtoull, if needed endif() endif() + + set(json_c_strtoull "strtoull") + if (NOT HAVE_STRTOULL) + # Use _strtoui64 if strtoull is not available. + check_symbol_exists(_strtoui64 "stdlib.h" __have_strtoui64) + if (__have_strtoui64) + set(HAVE_STRTOULL 1) + set(json_c_strtoull "_strtoui64") + endif() + endif() endif() diff --git a/cmake/config.h.in b/cmake/config.h.in index 628ddfe6..3539d6f2 100644 --- a/cmake/config.h.in +++ b/cmake/config.h.in @@ -137,6 +137,8 @@ #cmakedefine HAVE_STRTOLL #cmakedefine strtoll @json_c_strtoll@ +#cmakedefine HAVE_STRTOULL +#cmakedefine strtoull @json_c_strtoull@ /* Have __thread */ #cmakedefine HAVE___THREAD diff --git a/config.h.win32 b/config.h.win32 index 0e14c7ad..a2896bfc 100644 --- a/config.h.win32 +++ b/config.h.win32 @@ -115,6 +115,8 @@ #cmakedefine HAVE_STRTOLL #cmakedefine strtoll @cmake_strtoll@ +#cmakedefine HAVE_STRTOULL +#cmakedefine strtoull @cmake_strtoull@ /* Define to 1 if you have the header file. */ #undef HAVE_SYSLOG_H diff --git a/configure.ac b/configure.ac index 120797e6..5fae89d7 100644 --- a/configure.ac +++ b/configure.ac @@ -200,6 +200,7 @@ AX_COMPILE_CHECK_SIZEOF(long) AX_COMPILE_CHECK_SIZEOF(long long) AX_COMPILE_CHECK_SIZEOF(size_t, [#include ]) AX_COMPILE_CHECK_SIZEOF(int64_t, [#include ]) +AX_COMPILE_CHECK_SIZEOF(uint64_t, [#include ]) AC_CONFIG_FILES([ Makefile diff --git a/json_inttypes.h b/json_inttypes.h index 3854913f..e047d4f1 100644 --- a/json_inttypes.h +++ b/json_inttypes.h @@ -17,6 +17,7 @@ #define PRId64 "I64d" #define SCNd64 "I64d" +#define PRIu64 "I64u" #endif diff --git a/json_object.c b/json_object.c index ded3661d..6bd8517a 100644 --- a/json_object.c +++ b/json_object.c @@ -51,6 +51,7 @@ static json_object_to_json_string_fn json_object_object_to_json_string; static json_object_to_json_string_fn json_object_boolean_to_json_string; static json_object_to_json_string_fn json_object_double_to_json_string_default; static json_object_to_json_string_fn json_object_int_to_json_string; +static json_object_to_json_string_fn json_object_uint_to_json_string; static json_object_to_json_string_fn json_object_string_to_json_string; static json_object_to_json_string_fn json_object_array_to_json_string; static json_object_to_json_string_fn _json_object_userdata_to_json_string; @@ -302,6 +303,9 @@ void json_object_set_serializer(json_object *jso, case json_type_int: jso->_to_json_string = &json_object_int_to_json_string; break; + case json_type_uint: + jso->_to_json_string = &json_object_uint_to_json_string; + break; case json_type_object: jso->_to_json_string = &json_object_object_to_json_string; break; @@ -592,6 +596,8 @@ json_bool json_object_get_boolean(const struct json_object *jso) return jso->o.c_boolean; case json_type_int: return (jso->o.c_int64 != 0); + case json_type_uint: + return (jso->o.c_uint64 != 0); case json_type_double: return (jso->o.c_double != 0); case json_type_string: @@ -622,6 +628,17 @@ static int json_object_int_to_json_string(struct json_object* jso, return printbuf_memappend (pb, sbuf, strlen(sbuf)); } +static int json_object_uint_to_json_string(struct json_object* jso, + struct printbuf *pb, + int level, + int flags) +{ + /* room for 20 digits, and a null term */ + char sbuf[21]; + snprintf(sbuf, sizeof(sbuf), "%" PRIu64, jso->o.c_uint64); + return printbuf_memappend (pb, sbuf, strlen(sbuf)); +} + struct json_object* json_object_new_int(int32_t i) { struct json_object *jso = json_object_new(json_type_int); @@ -661,6 +678,10 @@ int32_t json_object_get_int(const struct json_object *jso) if (cint64 >= INT32_MAX) return INT32_MAX; return (int32_t) cint64; + case json_type_uint: + if (jso->o.c_uint64 >= INT32_MAX) + return INT32_MAX; + return (int32_t)jso->o.c_uint64; case json_type_double: if (jso->o.c_double <= INT32_MIN) return INT32_MIN; @@ -691,6 +712,16 @@ struct json_object* json_object_new_int64(int64_t i) return jso; } +struct json_object* json_object_new_uint64(uint64_t i) +{ + struct json_object *jso = json_object_new(json_type_uint); + if (!jso) + return NULL; + jso->_to_json_string = &json_object_uint_to_json_string; + jso->o.c_uint64 = i; + return jso; +} + int64_t json_object_get_int64(const struct json_object *jso) { int64_t cint; @@ -701,6 +732,10 @@ int64_t json_object_get_int64(const struct json_object *jso) { case json_type_int: return jso->o.c_int64; + case json_type_uint: + if (jso->o.c_uint64 >= INT64_MAX) + return INT64_MAX; + return (int64_t)jso->o.c_uint64; case json_type_double: // INT64_MAX can't be exactly represented as a double // so cast to tell the compiler it's ok to round up. @@ -720,6 +755,39 @@ int64_t json_object_get_int64(const struct json_object *jso) } } +uint64_t json_object_get_uint64(const struct json_object *jso) +{ + uint64_t cuint; + + if (!jso) + return 0; + switch(jso->o_type) + { + case json_type_int: + if (jso->o.c_int64 < 0) + return 0; + return (uint64_t)jso->o.c_int64; + case json_type_uint: + return jso->o.c_uint64; + case json_type_double: + // UINT64_MAX can't be exactly represented as a double + // so cast to tell the compiler it's ok to round up. + if (jso->o.c_double >= (double)UINT64_MAX) + return UINT64_MAX; + if (jso->o.c_double < 0) + return 0; + return (uint64_t)jso->o.c_double; + case json_type_boolean: + return jso->o.c_boolean; + case json_type_string: + if (json_parse_uint64(get_string_component(jso), &cuint) == 0) + return cuint; + /* FALLTHRU */ + default: + return 0; + } +} + int json_object_set_int64(struct json_object *jso,int64_t new_value){ if (!jso || jso->o_type!=json_type_int) return 0; @@ -727,6 +795,13 @@ int json_object_set_int64(struct json_object *jso,int64_t new_value){ return 1; } +int json_object_set_uint64(struct json_object *jso,uint64_t new_value){ + if (!jso || jso->o_type!=json_type_uint) + return 0; + jso->o.c_uint64=new_value; + return 1; +} + int json_object_int_inc(struct json_object *jso, int64_t val) { if (!jso || jso->o_type != json_type_int) return 0; @@ -740,6 +815,17 @@ int json_object_int_inc(struct json_object *jso, int64_t val) { return 1; } +int json_object_uint_inc(struct json_object *jso, uint64_t val) { + if (!jso || jso->o_type != json_type_uint) + return 0; + if (jso->o.c_uint64 > UINT64_MAX - val) { + jso->o.c_uint64 = UINT64_MAX; + } else { + jso->o.c_uint64 += val; + } + return 1; +} + /* json_object_double */ #if defined(HAVE___THREAD) @@ -962,6 +1048,8 @@ double json_object_get_double(const struct json_object *jso) return jso->o.c_double; case json_type_int: return jso->o.c_int64; + case json_type_uint: + return jso->o.c_uint64; case json_type_boolean: return jso->o.c_boolean; case json_type_string: @@ -1342,6 +1430,9 @@ int json_object_equal(struct json_object* jso1, struct json_object* jso2) case json_type_int: return (jso1->o.c_int64 == jso2->o.c_int64); + case json_type_uint: + return (jso1->o.c_uint64 == jso2->o.c_uint64); + case json_type_string: return (jso1->o.c_string.len == jso2->o.c_string.len && memcmp(get_string_component(jso1), @@ -1405,6 +1496,10 @@ int json_c_shallow_copy_default(json_object *src, json_object *parent, const cha *dst = json_object_new_int64(src->o.c_int64); break; + case json_type_uint: + *dst = json_object_new_uint64(src->o.c_uint64); + break; + case json_type_string: *dst = json_object_new_string(get_string_component(src)); break; diff --git a/json_object.h b/json_object.h index c36d68bf..4e13ec19 100644 --- a/json_object.h +++ b/json_object.h @@ -176,6 +176,7 @@ typedef enum json_type { json_type_boolean, json_type_double, json_type_int, + json_type_uint, json_type_object, json_type_array, json_type_string @@ -210,6 +211,7 @@ JSON_EXPORT int json_object_put(struct json_object *obj); json_type_boolean, json_type_double, json_type_int, + json_type_uint, json_type_object, json_type_array, json_type_string @@ -226,6 +228,7 @@ JSON_EXPORT int json_object_is_type(const struct json_object *obj, enum json_typ json_type_boolean, json_type_double, json_type_int, + json_type_uint, json_type_object, json_type_array, json_type_string @@ -701,6 +704,13 @@ JSON_EXPORT struct json_object* json_object_new_int(int32_t i); JSON_EXPORT struct json_object* json_object_new_int64(int64_t i); +/** Create a new empty json_object of type json_type_uint + * @param i the integer + * @returns a json_object of type json_type_uint + */ +JSON_EXPORT struct json_object* json_object_new_uint64(uint64_t i); + + /** Get the int value of a json_object * * The type is coerced to a int if the passed object is not a int. @@ -745,6 +755,19 @@ JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value); */ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val); +/** Increment a json_type_uint object by the given amount, which may be negative. + * + * If the type of obj is not json_type_uint then 0 is returned with no further + * action taken. + * If the addition would result in a overflow, the object value + * is set to UINT64_MAX. + * Neither overflow nor underflow affect the return value. + * + * @param obj the json_object instance + * @param val the value to add + * @returns 1 if the increment succeded, 0 otherwise + */ +JSON_EXPORT int json_object_uint_inc(struct json_object *obj, uint64_t val); /** Get the int value of a json_object * @@ -761,6 +784,20 @@ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val); */ JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj); +/** Get the uint value of a json_object + * + * The type is coerced to a uint64 if the passed object is not a uint64. + * double objects will return their uint64 conversion. Strings will be + * parsed as an uint64. If no conversion exists then 0 is returned. + * + * NOTE: Set errno to 0 directly before a call to this function to determine + * whether or not conversion was successful (it does not clear the value for + * you). + * + * @param obj the json_object instance + * @returns an uint64 + */ +JSON_EXPORT uint64_t json_object_get_uint64(const struct json_object *obj); /** Set the int64_t value of a json_object * @@ -774,6 +811,18 @@ JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj); */ JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value); +/** Set the uint64_t value of a json_object + * + * The type of obj is checked to be a json_type_uint and 0 is returned + * if it is not without any further actions. If type of obj is json_type_uint + * the object value is changed to new_value + * + * @param obj the json_object instance + * @param new_value the value to be set + * @returns 1 if value is set correctly, 0 otherwise + */ +JSON_EXPORT int json_object_set_uint64(struct json_object *obj,uint64_t new_value); + /* double type methods */ /** Create a new empty json_object of type json_type_double diff --git a/json_object_private.h b/json_object_private.h index 4c6681ae..f7109b77 100644 --- a/json_object_private.h +++ b/json_object_private.h @@ -35,6 +35,7 @@ struct json_object json_bool c_boolean; double c_double; int64_t c_int64; + uint64_t c_uint64; struct lh_table *c_object; struct array_list *c_array; struct { diff --git a/json_tokener.c b/json_tokener.c index 246d5bd7..68795c66 100644 --- a/json_tokener.c +++ b/json_tokener.c @@ -792,21 +792,33 @@ struct json_object* json_tokener_parse_ex(struct json_tokener *tok, } { int64_t num64; + uint64_t numuint64; double numd; - if (!tok->is_double && json_parse_int64(tok->pb->buf, &num64) == 0) { - if (num64 && tok->pb->buf[0]=='0' && + if (!tok->is_double && tok->pb->buf[0] == '-' + && json_parse_int64(tok->pb->buf, &num64) == 0) { + current = json_object_new_int64(num64); + if(current == NULL) + goto out; + } else if ( !tok->is_double && tok->pb->buf[0] != '-' + && json_parse_uint64(tok->pb->buf, &numuint64) == 0) { + if (numuint64 && tok->pb->buf[0]=='0' && (tok->flags & JSON_TOKENER_STRICT)) { - /* in strict mode, number must not start with 0 */ tok->err = json_tokener_error_parse_number; goto out; } - current = json_object_new_int64(num64); - if(current == NULL) - goto out; - } - else if(tok->is_double && json_parse_double(tok->pb->buf, &numd) == 0) + if (numuint64 <= INT64_MAX){ + num64 = (uint64_t) numuint64; + current = json_object_new_int64(num64); + if(current == NULL) + goto out; + } else { + current = json_object_new_uint64(numuint64); + if(current == NULL) + goto out; + } + } else if(tok->is_double && json_parse_double(tok->pb->buf, &numd) == 0) { - current = json_object_new_double_s(numd, tok->pb->buf); + current = json_object_new_double_s(numd, tok->pb->buf); if(current == NULL) goto out; } else { diff --git a/json_util.c b/json_util.c index 3ff631dd..8902d31a 100644 --- a/json_util.c +++ b/json_util.c @@ -40,8 +40,9 @@ #ifdef WIN32 # if MSC_VER < 1800 -/* strtoll is available only since Visual Studio 2013 */ +/* strtoll/strtoull is available only since Visual Studio 2013 */ # define strtoll _strtoi64 +# define strtoull _strtoui64 # endif # define WIN32_LEAN_AND_MEAN # include @@ -230,6 +231,23 @@ int json_parse_int64(const char *buf, int64_t *retval) return ((val == 0 && errno != 0) || (end == buf)) ? 1 : 0; } +int json_parse_uint64(const char *buf, uint64_t *retval) +{ + char *end = NULL; + uint64_t val; + errno = 1; + + while (*buf == ' ') { + buf++; + } + if (*buf == '-') errno = 0; + + val = strtoull(buf, &end, 10); + if (end != buf) + *retval = val; + return ((errno == 0) || (end == buf)) ? 1 : 0; +} + #ifndef HAVE_REALLOC void* rpl_realloc(void* p, size_t n) { @@ -248,6 +266,7 @@ static const char* json_type_name[] = { "boolean", "double", "int", + "uint", "object", "array", "string", diff --git a/json_util.h b/json_util.h index 96208093..43adca94 100644 --- a/json_util.h +++ b/json_util.h @@ -103,6 +103,7 @@ JSON_EXPORT const char *json_util_get_last_err(void); JSON_EXPORT int json_parse_int64(const char *buf, int64_t *retval); +JSON_EXPORT int json_parse_uint64(const char *buf, uint64_t *retval); JSON_EXPORT int json_parse_double(const char *buf, double *retval); /** diff --git a/json_visit.c b/json_visit.c index 1126ff8d..44196142 100644 --- a/json_visit.c +++ b/json_visit.c @@ -57,6 +57,7 @@ static int _json_c_visit(json_object *jso, json_object *parent_jso, case json_type_boolean: case json_type_double: case json_type_int: + case json_type_uint: case json_type_string: // we already called userfunc above, move on to the next object return JSON_C_VISIT_RETURN_CONTINUE; diff --git a/tests/test_cast.c b/tests/test_cast.c index 7e2bcd5e..3daf5e11 100644 --- a/tests/test_cast.c +++ b/tests/test_cast.c @@ -25,10 +25,13 @@ int main(int argc, char **argv) \"decimal_number\": 99.55,\n\ \"boolean_true\": true,\n\ \"boolean_false\": false,\n\ - \"big_number\": 2147483649,\n\ + \"int64_number\": 2147483649,\n\ + \"negative_number\": -321321321,\n\ \"a_null\": null,\n\ }"; /* Note: 2147483649 = INT_MAX + 2 */ + /* Note: 9223372036854775809 = INT64_MAX + 2 */ + /* Note: 18446744073709551617 = UINT64_MAX + 2 */ struct json_object *new_obj; @@ -43,7 +46,8 @@ int main(int argc, char **argv) getit(new_obj, "decimal_number"); getit(new_obj, "boolean_true"); getit(new_obj, "boolean_false"); - getit(new_obj, "big_number"); + getit(new_obj, "int64_number"); + getit(new_obj, "negative_number"); getit(new_obj, "a_null"); // Now check the behaviour of the json_object_is_type() function. @@ -55,7 +59,8 @@ int main(int argc, char **argv) checktype(new_obj, "decimal_number"); checktype(new_obj, "boolean_true"); checktype(new_obj, "boolean_false"); - checktype(new_obj, "big_number"); + checktype(new_obj, "int64_number"); + checktype(new_obj, "negative_number"); checktype(new_obj, "a_null"); json_object_put(new_obj); @@ -76,6 +81,8 @@ static void getit(struct json_object *new_obj, const char *field) json_object_get_int(o)); printf("new_obj.%s json_object_get_int64()=%" PRId64 "\n", field, json_object_get_int64(o)); + printf("new_obj.%s json_object_get_uint64()=%" PRIu64 "\n", field, + json_object_get_uint64(o)); printf("new_obj.%s json_object_get_boolean()=%d\n", field, json_object_get_boolean(o)); printf("new_obj.%s json_object_get_double()=%f\n", field, @@ -84,11 +91,12 @@ static void getit(struct json_object *new_obj, const char *field) static void checktype_header() { - printf("json_object_is_type: %s,%s,%s,%s,%s,%s,%s\n", + printf("json_object_is_type: %s,%s,%s,%s,%s,%s,%s,%s\n", json_type_to_name(json_type_null), json_type_to_name(json_type_boolean), json_type_to_name(json_type_double), json_type_to_name(json_type_int), + json_type_to_name(json_type_uint), json_type_to_name(json_type_object), json_type_to_name(json_type_array), json_type_to_name(json_type_string)); @@ -99,12 +107,13 @@ static void checktype(struct json_object *new_obj, const char *field) if (field && !json_object_object_get_ex(new_obj, field, &o)) printf("Field %s does not exist\n", field); - printf("new_obj%s%-18s: %d,%d,%d,%d,%d,%d,%d\n", + printf("new_obj%s%-18s: %d,%d,%d,%d,%d,%d,%d,%d\n", field ? "." : " ", field ? field : "", json_object_is_type(o, json_type_null), json_object_is_type(o, json_type_boolean), json_object_is_type(o, json_type_double), json_object_is_type(o, json_type_int), + json_object_is_type(o, json_type_uint), json_object_is_type(o, json_type_object), json_object_is_type(o, json_type_array), json_object_is_type(o, json_type_string)); diff --git a/tests/test_cast.expected b/tests/test_cast.expected index 76ff8231..92ea886d 100644 --- a/tests/test_cast.expected +++ b/tests/test_cast.expected @@ -4,53 +4,68 @@ Parsed input: { "decimal_number": 99.55, "boolean_true": true, "boolean_false": false, - "big_number": 2147483649, + "int64_number": 2147483649, + "negative_number": -321321321, "a_null": null, } Result is not NULL new_obj.string_of_digits json_object_get_type()=string new_obj.string_of_digits json_object_get_int()=123 new_obj.string_of_digits json_object_get_int64()=123 +new_obj.string_of_digits json_object_get_uint64()=123 new_obj.string_of_digits json_object_get_boolean()=1 new_obj.string_of_digits json_object_get_double()=123.000000 new_obj.regular_number json_object_get_type()=int new_obj.regular_number json_object_get_int()=222 new_obj.regular_number json_object_get_int64()=222 +new_obj.regular_number json_object_get_uint64()=222 new_obj.regular_number json_object_get_boolean()=1 new_obj.regular_number json_object_get_double()=222.000000 new_obj.decimal_number json_object_get_type()=double new_obj.decimal_number json_object_get_int()=99 new_obj.decimal_number json_object_get_int64()=99 +new_obj.decimal_number json_object_get_uint64()=99 new_obj.decimal_number json_object_get_boolean()=1 new_obj.decimal_number json_object_get_double()=99.550000 new_obj.boolean_true json_object_get_type()=boolean new_obj.boolean_true json_object_get_int()=1 new_obj.boolean_true json_object_get_int64()=1 +new_obj.boolean_true json_object_get_uint64()=1 new_obj.boolean_true json_object_get_boolean()=1 new_obj.boolean_true json_object_get_double()=1.000000 new_obj.boolean_false json_object_get_type()=boolean new_obj.boolean_false json_object_get_int()=0 new_obj.boolean_false json_object_get_int64()=0 +new_obj.boolean_false json_object_get_uint64()=0 new_obj.boolean_false json_object_get_boolean()=0 new_obj.boolean_false json_object_get_double()=0.000000 -new_obj.big_number json_object_get_type()=int -new_obj.big_number json_object_get_int()=2147483647 -new_obj.big_number json_object_get_int64()=2147483649 -new_obj.big_number json_object_get_boolean()=1 -new_obj.big_number json_object_get_double()=2147483649.000000 +new_obj.int64_number json_object_get_type()=int +new_obj.int64_number json_object_get_int()=2147483647 +new_obj.int64_number json_object_get_int64()=2147483649 +new_obj.int64_number json_object_get_uint64()=2147483649 +new_obj.int64_number json_object_get_boolean()=1 +new_obj.int64_number json_object_get_double()=2147483649.000000 +new_obj.negative_number json_object_get_type()=int +new_obj.negative_number json_object_get_int()=-321321321 +new_obj.negative_number json_object_get_int64()=-321321321 +new_obj.negative_number json_object_get_uint64()=0 +new_obj.negative_number json_object_get_boolean()=1 +new_obj.negative_number json_object_get_double()=-321321321.000000 new_obj.a_null json_object_get_type()=null new_obj.a_null json_object_get_int()=0 new_obj.a_null json_object_get_int64()=0 +new_obj.a_null json_object_get_uint64()=0 new_obj.a_null json_object_get_boolean()=0 new_obj.a_null json_object_get_double()=0.000000 ================================ -json_object_is_type: null,boolean,double,int,object,array,string -new_obj : 0,0,0,0,1,0,0 -new_obj.string_of_digits : 0,0,0,0,0,0,1 -new_obj.regular_number : 0,0,0,1,0,0,0 -new_obj.decimal_number : 0,0,1,0,0,0,0 -new_obj.boolean_true : 0,1,0,0,0,0,0 -new_obj.boolean_false : 0,1,0,0,0,0,0 -new_obj.big_number : 0,0,0,1,0,0,0 -new_obj.a_null : 1,0,0,0,0,0,0 +json_object_is_type: null,boolean,double,int,uint,object,array,string +new_obj : 0,0,0,0,0,1,0,0 +new_obj.string_of_digits : 0,0,0,0,0,0,0,1 +new_obj.regular_number : 0,0,0,1,0,0,0,0 +new_obj.decimal_number : 0,0,1,0,0,0,0,0 +new_obj.boolean_true : 0,1,0,0,0,0,0,0 +new_obj.boolean_false : 0,1,0,0,0,0,0,0 +new_obj.int64_number : 0,0,0,1,0,0,0,0 +new_obj.negative_number : 0,0,0,1,0,0,0,0 +new_obj.a_null : 1,0,0,0,0,0,0,0 diff --git a/tests/test_compare.c b/tests/test_compare.c index 49b05870..13ad3ea0 100644 --- a/tests/test_compare.c +++ b/tests/test_compare.c @@ -15,6 +15,9 @@ int main() struct json_object *int1 = json_object_new_int(0); struct json_object *int2 = json_object_new_int(1); struct json_object *int3 = json_object_new_int(1); + struct json_object *uint1 = json_object_new_uint64(0); + struct json_object *uint2 = json_object_new_uint64(1); + struct json_object *uint3 = json_object_new_uint64(1); if (!json_object_equal(int1, int2)) printf("JSON integer comparison is correct\n"); @@ -31,9 +34,27 @@ int main() else printf("JSON same integer comparison failed\n"); + if (!json_object_equal(uint1, uint2)) + printf("JSON usigned integer comparison is correct\n"); + else + printf("JSON usigned integer comparison failed\n"); + + if (json_object_equal(uint1, uint1)) + printf("JSON same usigned object comparison is correct\n"); + else + printf("JSON same usigned object comparison failed\n"); + + if (json_object_equal(uint2, uint3)) + printf("JSON same usigned integer comparison is correct\n"); + else + printf("JSON same usigned integer comparison failed\n"); + json_object_put(int1); json_object_put(int2); json_object_put(int3); + json_object_put(uint1); + json_object_put(uint2); + json_object_put(uint3); /* string tests */ struct json_object *str1 = json_object_new_string("TESTSTRING"); diff --git a/tests/test_compare.expected b/tests/test_compare.expected index 5468f83d..a183aabe 100644 --- a/tests/test_compare.expected +++ b/tests/test_compare.expected @@ -1,6 +1,9 @@ JSON integer comparison is correct JSON same object comparison is correct JSON same integer comparison is correct +JSON usigned integer comparison is correct +JSON same usigned object comparison is correct +JSON same usigned integer comparison is correct Comparing equal strings is correct Comparing different strings is correct Comparing equal doubles is correct diff --git a/tests/test_int_add.c b/tests/test_int_add.c index 08a88022..8b02e793 100644 --- a/tests/test_int_add.c +++ b/tests/test_int_add.c @@ -41,6 +41,18 @@ int main(int argc, char **argv) assert(json_object_get_int64(tmp) != INT64_MIN); json_object_put(tmp); printf("INT64 ADD UNDERFLOW PASSED\n"); + tmp = json_object_new_uint64(321321321); + json_object_uint_inc(tmp, 321321321); + assert(json_object_get_uint64(tmp) == 642642642); + json_object_put(tmp); + printf("UINT64 ADD PASSED\n"); + tmp = json_object_new_uint64(UINT64_MAX); + json_object_uint_inc(tmp, 100); + assert(json_object_get_uint64(tmp) == UINT64_MAX); + json_object_uint_inc(tmp, -100); + assert(json_object_get_uint64(tmp) != INT64_MAX); + json_object_put(tmp); + printf("UINT64 ADD OVERFLOW PASSED\n"); printf("PASSED\n"); return 0; diff --git a/tests/test_int_add.expected b/tests/test_int_add.expected index 61c205c3..144233ab 100644 --- a/tests/test_int_add.expected +++ b/tests/test_int_add.expected @@ -4,4 +4,6 @@ INT ADD UNDERFLOW PASSED INT64 ADD PASSED INT64 ADD OVERFLOW PASSED INT64 ADD UNDERFLOW PASSED +UINT64 ADD PASSED +UINT64 ADD OVERFLOW PASSED PASSED diff --git a/tests/test_parse.c b/tests/test_parse.c index f8fc8b7a..61844cad 100644 --- a/tests/test_parse.c +++ b/tests/test_parse.c @@ -128,8 +128,18 @@ static void test_basic_parse() single_basic_parse("[0e]", 1); single_basic_parse("[0e+]", 1); single_basic_parse("[0e+-1]", 1); - single_basic_parse("[18446744073709551616]", 1); single_basic_parse("\"hello world!\"", 1); + + // uint64/int64 range test + single_basic_parse("[9223372036854775806]", 1); + single_basic_parse("[9223372036854775807]", 1); + single_basic_parse("[9223372036854775808]", 1); + single_basic_parse("[-9223372036854775807]", 1); + single_basic_parse("[-9223372036854775808]", 1); + single_basic_parse("[-9223372036854775809]", 1); + single_basic_parse("[18446744073709551614]", 1); + single_basic_parse("[18446744073709551615]", 1); + single_basic_parse("[18446744073709551616]", 1); } static void test_utf8_parse() diff --git a/tests/test_parse.expected b/tests/test_parse.expected index 68e55b1b..83c55737 100644 --- a/tests/test_parse.expected +++ b/tests/test_parse.expected @@ -66,8 +66,16 @@ new_obj.to_string(false)=false new_obj.to_string([0e])=[ 0.0 ] new_obj.to_string([0e+])=[ 0.0 ] new_obj.to_string([0e+-1])=null -new_obj.to_string([18446744073709551616])=[ 9223372036854775807 ] new_obj.to_string("hello world!")="hello world!" +new_obj.to_string([9223372036854775806])=[ 9223372036854775806 ] +new_obj.to_string([9223372036854775807])=[ 9223372036854775807 ] +new_obj.to_string([9223372036854775808])=[ 9223372036854775808 ] +new_obj.to_string([-9223372036854775807])=[ -9223372036854775807 ] +new_obj.to_string([-9223372036854775808])=[ -9223372036854775808 ] +new_obj.to_string([-9223372036854775809])=[ -9223372036854775808 ] +new_obj.to_string([18446744073709551614])=[ 18446744073709551614 ] +new_obj.to_string([18446744073709551615])=[ 18446744073709551615 ] +new_obj.to_string([18446744073709551616])=[ 18446744073709551615 ] ================================== new_obj.to_string()=null new_obj.to_string({})=null diff --git a/tests/test_parse_int64.c b/tests/test_parse_int64.c index c251e013..33dd9bc2 100644 --- a/tests/test_parse_int64.c +++ b/tests/test_parse_int64.c @@ -15,10 +15,18 @@ void checkit(const char *buf) printf("buf=%s parseit=%d, value=%" PRId64 " \n", buf, retval, cint64); } +void checkit_uint(const char *buf) +{ + uint64_t cuint64 = 666; + + int retval = json_parse_uint64(buf, &cuint64); + printf("buf=%s parseit=%d, value=%" PRIu64 " \n", buf, retval, cuint64); +} + /** - * This test calls json_parse_int64 with a variety of different strings. - * It's purpose is to ensure that the results are consistent across all - * different environments that it might be executed in. + * This test calls json_parse_int64 and json_parse_int64 with a variety + * of different strings. It's purpose is to ensure that the results are + * consistent across all different environments that it might be executed in. * * This always exits with a 0 exit value. The output should be compared * against previously saved expected output. @@ -27,6 +35,7 @@ int main() { char buf[100]; + printf("==========json_parse_int64() test===========\n"); checkit("x"); checkit("0"); @@ -59,8 +68,10 @@ int main() checkit(buf); strcpy(buf, "4294967295"); // aka UINT32_MAX + checkit(buf); - sprintf(buf, "4294967296"); // aka UINT32_MAX + 1 + strcpy(buf, "4294967296"); // aka UINT32_MAX + 1 + checkit(buf); strcpy(buf, "21474836470"); // INT32_MAX * 10 checkit(buf); @@ -111,5 +122,68 @@ int main() strcpy(buf, "123"); checkit(buf); + printf("\n==========json_parse_uint64() test===========\n"); + checkit_uint("x"); + + checkit_uint("0"); + checkit_uint("-0"); + + checkit_uint("00000000"); + checkit_uint("-00000000"); + + checkit_uint("1"); + + strcpy(buf, "2147483647"); // aka INT32_MAX + checkit_uint(buf); + + strcpy(buf, "-1"); + checkit_uint(buf); + + strcpy(buf, "-9223372036854775808"); + checkit_uint(buf); + + strcpy(buf, " 1"); + checkit_uint(buf); + + strcpy(buf, "00001234"); + checkit_uint(buf); + + strcpy(buf, "0001234x"); + checkit_uint(buf); + + strcpy(buf, "4294967295"); // aka UINT32_MAX + checkit_uint(buf); + + strcpy(buf, "4294967296"); // aka UINT32_MAX + 1 + checkit_uint(buf); + + strcpy(buf, "21474836470"); // INT32_MAX * 10 + checkit_uint(buf); + + strcpy(buf, "31474836470"); // INT32_MAX * 10 + a bunch + checkit_uint(buf); + + strcpy(buf, "9223372036854775806"); // INT64_MAX - 1 + checkit_uint(buf); + + strcpy(buf, "9223372036854775807"); // INT64_MAX + checkit_uint(buf); + + strcpy(buf, "9223372036854775808"); // INT64_MAX + 1 + checkit_uint(buf); + + strcpy(buf, "18446744073709551614"); // UINT64_MAX - 1 + checkit_uint(buf); + + strcpy(buf, "18446744073709551615"); // UINT64_MAX + checkit_uint(buf); + + strcpy(buf, "18446744073709551616"); // UINT64_MAX + 1 + checkit_uint(buf); + + // Ensure we can still parse valid numbers after parsing out of range ones. + strcpy(buf, "123"); + checkit_uint(buf); + return 0; } diff --git a/tests/test_parse_int64.expected b/tests/test_parse_int64.expected index d9cdf5ac..f4c5750b 100644 --- a/tests/test_parse_int64.expected +++ b/tests/test_parse_int64.expected @@ -1,3 +1,4 @@ +==========json_parse_int64() test=========== buf=x parseit=1, value=-666 buf=0 parseit=0, value=0 buf=-0 parseit=0, value=0 @@ -11,6 +12,8 @@ buf=00001234 parseit=0, value=1234 buf=0001234x parseit=0, value=1234 buf=-00001234 parseit=0, value=-1234 buf=-00001234x parseit=0, value=-1234 +buf=4294967295 parseit=0, value=4294967295 +buf=4294967296 parseit=0, value=4294967296 buf=21474836470 parseit=0, value=21474836470 buf=31474836470 parseit=0, value=31474836470 buf=-2147483647 parseit=0, value=-2147483647 @@ -27,3 +30,28 @@ buf=18446744073709551615 parseit=0, value=9223372036854775807 buf=18446744073709551616 parseit=0, value=9223372036854775807 buf=-18446744073709551616 parseit=0, value=-9223372036854775808 buf=123 parseit=0, value=123 + +==========json_parse_uint64() test=========== +buf=x parseit=1, value=666 +buf=0 parseit=0, value=0 +buf=-0 parseit=1, value=0 +buf=00000000 parseit=0, value=0 +buf=-00000000 parseit=1, value=0 +buf=1 parseit=0, value=1 +buf=2147483647 parseit=0, value=2147483647 +buf=-1 parseit=1, value=18446744073709551615 +buf=-9223372036854775808 parseit=1, value=9223372036854775808 +buf= 1 parseit=0, value=1 +buf=00001234 parseit=0, value=1234 +buf=0001234x parseit=0, value=1234 +buf=4294967295 parseit=0, value=4294967295 +buf=4294967296 parseit=0, value=4294967296 +buf=21474836470 parseit=0, value=21474836470 +buf=31474836470 parseit=0, value=31474836470 +buf=9223372036854775806 parseit=0, value=9223372036854775806 +buf=9223372036854775807 parseit=0, value=9223372036854775807 +buf=9223372036854775808 parseit=0, value=9223372036854775808 +buf=18446744073709551614 parseit=0, value=18446744073709551614 +buf=18446744073709551615 parseit=0, value=18446744073709551615 +buf=18446744073709551616 parseit=0, value=18446744073709551615 +buf=123 parseit=0, value=123 diff --git a/tests/test_set_value.c b/tests/test_set_value.c index 6cd95636..25124be1 100644 --- a/tests/test_set_value.c +++ b/tests/test_set_value.c @@ -15,6 +15,16 @@ int main(int argc, char **argv) assert (json_object_get_int64(tmp)==321321321); json_object_put(tmp); printf("INT64 PASSED\n"); + tmp=json_object_new_uint64(123); + assert (json_object_get_int(tmp)==123); + assert (json_object_get_int64(tmp)==123); + assert (json_object_get_uint64(tmp)==123); + json_object_set_uint64(tmp,(uint64_t)321321321); + assert (json_object_get_uint64(tmp)==321321321); + json_object_set_uint64(tmp,9223372036854775808U); + assert (json_object_get_uint64(tmp)==9223372036854775808U); + json_object_put(tmp); + printf("UINT64 PASSED\n"); tmp=json_object_new_boolean(1); assert (json_object_get_boolean(tmp)==1); json_object_set_boolean(tmp,0); @@ -29,6 +39,12 @@ int main(int argc, char **argv) assert (json_object_get_double(tmp)==34.56); json_object_set_double(tmp,6435.34); assert (json_object_get_double(tmp)==6435.34); + json_object_set_double(tmp,2e21); + assert (json_object_get_int64(tmp)==INT64_MAX); + assert (json_object_get_uint64(tmp)==UINT64_MAX); + json_object_set_double(tmp,-2e21); + assert (json_object_get_int64(tmp)==INT64_MIN); + assert (json_object_get_uint64(tmp)==0); json_object_put(tmp); printf("DOUBLE PASSED\n"); #define SHORT "SHORT" diff --git a/tests/test_set_value.expected b/tests/test_set_value.expected index 4cbd5bcd..18dd49e3 100644 --- a/tests/test_set_value.expected +++ b/tests/test_set_value.expected @@ -1,5 +1,6 @@ INT PASSED INT64 PASSED +UINT64 PASSED BOOL PASSED DOUBLE PASSED STRING PASSED