From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Serge Petrenko Subject: [PATCH 2/5] decimal: allow to encode/decode decimals as MsgPack Date: Wed, 17 Jul 2019 18:33:43 +0300 Message-Id: <5f07a0f042b2b6c2d7afc2e595ecd56996afb48a.1563376957.git.sergepetrenko@tarantool.org> In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit To: vdavydov.dev@gmail.com Cc: tarantool-patches@freelists.org, Serge Petrenko List-ID: This patch adds the methods necessary to encode and decode decimals to MsgPack. MsgPack EXT type (MP_EXT) together with a new extension type MP_DECIMAL is used as a record header. The decimal MsgPack representation looks like this: +--------+-------------------+------------+===============+ | MP_EXT | length (optional) | MP_DECIMAL | PackedDecimal | +--------+-------------------+------------+===============+ The whole record may be encoded and decoded with mp_encode_decimal() and mp_decode_decimal(). This is equivalent to performing mp_encode_extl()/mp_decode_extl() on the first 3 fields and decimal_pack/unpack() on the PackedDecimal field. Part of #692 --- src/lib/core/CMakeLists.txt | 1 + src/lib/core/mp_decimal.c | 72 +++++++++++++ src/lib/core/mp_decimal.h | 62 +++++++++++ src/lib/core/mp_user_types.h | 38 +++++++ test/unit/decimal.c | 60 ++++++++++- test/unit/decimal.result | 202 ++++++++++++++++++++++++++++++++++- 6 files changed, 433 insertions(+), 2 deletions(-) create mode 100644 src/lib/core/mp_decimal.c create mode 100644 src/lib/core/mp_decimal.h create mode 100644 src/lib/core/mp_user_types.h diff --git a/src/lib/core/CMakeLists.txt b/src/lib/core/CMakeLists.txt index 66e430a25..e0a717aa3 100644 --- a/src/lib/core/CMakeLists.txt +++ b/src/lib/core/CMakeLists.txt @@ -27,6 +27,7 @@ set(core_sources mpstream.c port.c decimal.c + mp_decimal.c ) if (TARGET_OS_NETBSD) diff --git a/src/lib/core/mp_decimal.c b/src/lib/core/mp_decimal.c new file mode 100644 index 000000000..1bcf316fa --- /dev/null +++ b/src/lib/core/mp_decimal.c @@ -0,0 +1,72 @@ +/* + * Copyright 2019, Tarantool AUTHORS, please see AUTHORS file. + * + * 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 ``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 + * 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 "mp_decimal.h" +#include "mp_user_types.h" +#include "msgpuck.h" +#include "decimal.h" + +uint32_t +mp_sizeof_decimal(const decimal_t *dec) +{ + return mp_sizeof_ext(decimal_len(dec)); +} + +decimal_t * +mp_decode_decimal(const char **data, decimal_t *dec) +{ + if (mp_typeof(**data) != MP_EXT) + return NULL; + + int8_t type; + uint32_t len; + const char *const svp = *data; + + len = mp_decode_extl(data, &type); + + if (type != MP_DECIMAL || len == 0) { + *data = svp; + return NULL; + } + decimal_t *res = decimal_unpack(data, len, dec); + if (!res) + *data = svp; + return res; +} + +char * +mp_encode_decimal(char *data, const decimal_t *dec) +{ + uint32_t len = decimal_len(dec); + data = mp_encode_extl(data, MP_DECIMAL, len); + data = decimal_pack(data, dec); + return data; +} diff --git a/src/lib/core/mp_decimal.h b/src/lib/core/mp_decimal.h new file mode 100644 index 000000000..a991a5f16 --- /dev/null +++ b/src/lib/core/mp_decimal.h @@ -0,0 +1,62 @@ +#ifndef TARANTOOL_LIB_CORE_MP_DECIMAL_INCLUDED +#define TARANTOOL_LIB_CORE_MP_DECIMAL_INCLUDED +/* + * Copyright 2019, Tarantool AUTHORS, please see AUTHORS file. + * + * 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 ``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 + * 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 "decimal.h" +#include + +/** + * \brief Calculate exact buffer size needed to store a decimal + * pointed to by \a dec. + */ +uint32_t +mp_sizeof_decimal(const decimal_t *dec); + +/** + * \brief Decode a decimal from MsgPack \a data + * \param data - buffer pointer + * \return the decoded decimal + * \post *data = *data + mp_sizeof_decimal(retval) + */ +decimal_t * +mp_decode_decimal(const char **data, decimal_t *dec); + +/** + * \brief Encode a decimal pointed to by \a dec. + * \parad dec - decimal pointer + * \param data - a buffer + * \return \a data + mp_sizeof_decimal(\a dec) + */ +char * +mp_encode_decimal(char *data, const decimal_t *dec); + +#endif diff --git a/src/lib/core/mp_user_types.h b/src/lib/core/mp_user_types.h new file mode 100644 index 000000000..9158b40d3 --- /dev/null +++ b/src/lib/core/mp_user_types.h @@ -0,0 +1,38 @@ +#ifndef TARANTOOL_LIB_CORE_MP_USER_TYPES_H_INCLUDED +#define TARANTOOL_LIB_CORE_MP_USER_TYPES_H_INCLUDED +/* + * Copyright 2019, Tarantool AUTHORS, please see AUTHORS file. + * + * 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 ``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 + * 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. + */ + +enum mp_user_type { + MP_DECIMAL = 0 +}; + +#endif diff --git a/test/unit/decimal.c b/test/unit/decimal.c index b587e1f14..dd64b95ed 100644 --- a/test/unit/decimal.c +++ b/test/unit/decimal.c @@ -1,5 +1,8 @@ #include "unit.h" #include "decimal.h" +#include "mp_decimal.h" +#include "mp_user_types.h" +#include "msgpuck.h" #include #include #include /* DBL_DIG */ @@ -71,6 +74,32 @@ char buf[32]; +#define test_mpdec(str) ({\ + decimal_t dec;\ + decimal_from_string(&dec, str);\ + uint32_t l1 = mp_sizeof_decimal(&dec);\ + ok(l1 <= 25 && l1 >= 4, "mp_sizeof_decimal("str")");\ + char *b1 = mp_encode_decimal(buf, &dec);\ + is(b1, buf + l1, "mp_sizeof_decimal("str") == len(mp_encode_decimal("str"))");\ + const char *b2 = buf;\ + const char *b3 = buf;\ + decimal_t d2;\ + mp_next(&b3);\ + is(b3, b1, "mp_next(mp_encode("str"))");\ + mp_decode_decimal(&b2, &d2);\ + is(b1, b2, "mp_decode(mp_encode("str") len");\ + is(decimal_compare(&dec, &d2), 0, "mp_decode(mp_encode("str")) value");\ + is(decimal_scale(&dec), decimal_scale(&d2), "mp_decode(mp_encode("str")) scale");\ + is(strcmp(decimal_to_string(&d2), str), 0, "str(mp_decode(mp_encode("str"))) == "str);\ + b2 = buf;\ + int8_t type;\ + uint32_t l2 = mp_decode_extl(&b2, &type);\ + is(type, MP_DECIMAL, "mp_ext_type is MP_DECIMAL");\ + is(&d2, decimal_unpack(&b2, l2, &d2), "decimal_unpack() after mp_decode_extl()");\ + is(decimal_compare(&dec, &d2), 0, "decimal_unpack() after mp_decode_extl() value");\ + is(b2, buf + l1, "decimal_unpack() after mp_decode_extl() len");\ +}) + #define test_decpack(str) ({\ decimal_t dec;\ decimal_from_string(&dec, str);\ @@ -125,10 +154,37 @@ test_pack_unpack(void) return check_plan(); } +static int +test_mp_decimal(void) +{ + plan(198); + + test_mpdec("0"); + test_mpdec("-0"); + test_mpdec("1"); + test_mpdec("-1"); + test_mpdec("0.1"); + test_mpdec("-0.1"); + test_mpdec("2.718281828459045"); + test_mpdec("-2.718281828459045"); + test_mpdec("3.141592653589793"); + test_mpdec("-3.141592653589793"); + test_mpdec("1234567891234567890.0987654321987654321"); + test_mpdec("-1234567891234567890.0987654321987654321"); + test_mpdec("0.0000000000000000000000000000000000001"); + test_mpdec("-0.0000000000000000000000000000000000001"); + test_mpdec("0.00000000000000000000000000000000000001"); + test_mpdec("-0.00000000000000000000000000000000000001"); + test_mpdec("99999999999999999999999999999999999999"); + test_mpdec("-99999999999999999999999999999999999999"); + + return check_plan(); +} + int main(void) { - plan(279); + plan(280); dectest(314, 271, uint64, uint64_t); dectest(65535, 23456, uint64, uint64_t); @@ -190,5 +246,7 @@ main(void) test_pack_unpack(); + test_mp_decimal(); + return check_plan(); } diff --git a/test/unit/decimal.result b/test/unit/decimal.result index 1c72cdfab..6d00996d3 100644 --- a/test/unit/decimal.result +++ b/test/unit/decimal.result @@ -1,4 +1,4 @@ -1..279 +1..280 ok 1 - decimal(314) ok 2 - decimal(271) ok 3 - decimal(314) + decimal(271) @@ -425,3 +425,203 @@ ok 278 - decimal_sqrt(-10) - error on wrong operands. ok 145 - unpack malformed decimal fails ok 146 - decode malformed decimal preserves buffer position ok 279 - subtests + 1..198 + ok 1 - mp_sizeof_decimal(0) + ok 2 - mp_sizeof_decimal(0) == len(mp_encode_decimal(0)) + ok 3 - mp_next(mp_encode(0)) + ok 4 - mp_decode(mp_encode(0) len + ok 5 - mp_decode(mp_encode(0)) value + ok 6 - mp_decode(mp_encode(0)) scale + ok 7 - str(mp_decode(mp_encode(0))) == 0 + ok 8 - mp_ext_type is MP_DECIMAL + ok 9 - decimal_unpack() after mp_decode_extl() + ok 10 - decimal_unpack() after mp_decode_extl() value + ok 11 - decimal_unpack() after mp_decode_extl() len + ok 12 - mp_sizeof_decimal(-0) + ok 13 - mp_sizeof_decimal(-0) == len(mp_encode_decimal(-0)) + ok 14 - mp_next(mp_encode(-0)) + ok 15 - mp_decode(mp_encode(-0) len + ok 16 - mp_decode(mp_encode(-0)) value + ok 17 - mp_decode(mp_encode(-0)) scale + ok 18 - str(mp_decode(mp_encode(-0))) == -0 + ok 19 - mp_ext_type is MP_DECIMAL + ok 20 - decimal_unpack() after mp_decode_extl() + ok 21 - decimal_unpack() after mp_decode_extl() value + ok 22 - decimal_unpack() after mp_decode_extl() len + ok 23 - mp_sizeof_decimal(1) + ok 24 - mp_sizeof_decimal(1) == len(mp_encode_decimal(1)) + ok 25 - mp_next(mp_encode(1)) + ok 26 - mp_decode(mp_encode(1) len + ok 27 - mp_decode(mp_encode(1)) value + ok 28 - mp_decode(mp_encode(1)) scale + ok 29 - str(mp_decode(mp_encode(1))) == 1 + ok 30 - mp_ext_type is MP_DECIMAL + ok 31 - decimal_unpack() after mp_decode_extl() + ok 32 - decimal_unpack() after mp_decode_extl() value + ok 33 - decimal_unpack() after mp_decode_extl() len + ok 34 - mp_sizeof_decimal(-1) + ok 35 - mp_sizeof_decimal(-1) == len(mp_encode_decimal(-1)) + ok 36 - mp_next(mp_encode(-1)) + ok 37 - mp_decode(mp_encode(-1) len + ok 38 - mp_decode(mp_encode(-1)) value + ok 39 - mp_decode(mp_encode(-1)) scale + ok 40 - str(mp_decode(mp_encode(-1))) == -1 + ok 41 - mp_ext_type is MP_DECIMAL + ok 42 - decimal_unpack() after mp_decode_extl() + ok 43 - decimal_unpack() after mp_decode_extl() value + ok 44 - decimal_unpack() after mp_decode_extl() len + ok 45 - mp_sizeof_decimal(0.1) + ok 46 - mp_sizeof_decimal(0.1) == len(mp_encode_decimal(0.1)) + ok 47 - mp_next(mp_encode(0.1)) + ok 48 - mp_decode(mp_encode(0.1) len + ok 49 - mp_decode(mp_encode(0.1)) value + ok 50 - mp_decode(mp_encode(0.1)) scale + ok 51 - str(mp_decode(mp_encode(0.1))) == 0.1 + ok 52 - mp_ext_type is MP_DECIMAL + ok 53 - decimal_unpack() after mp_decode_extl() + ok 54 - decimal_unpack() after mp_decode_extl() value + ok 55 - decimal_unpack() after mp_decode_extl() len + ok 56 - mp_sizeof_decimal(-0.1) + ok 57 - mp_sizeof_decimal(-0.1) == len(mp_encode_decimal(-0.1)) + ok 58 - mp_next(mp_encode(-0.1)) + ok 59 - mp_decode(mp_encode(-0.1) len + ok 60 - mp_decode(mp_encode(-0.1)) value + ok 61 - mp_decode(mp_encode(-0.1)) scale + ok 62 - str(mp_decode(mp_encode(-0.1))) == -0.1 + ok 63 - mp_ext_type is MP_DECIMAL + ok 64 - decimal_unpack() after mp_decode_extl() + ok 65 - decimal_unpack() after mp_decode_extl() value + ok 66 - decimal_unpack() after mp_decode_extl() len + ok 67 - mp_sizeof_decimal(2.718281828459045) + ok 68 - mp_sizeof_decimal(2.718281828459045) == len(mp_encode_decimal(2.718281828459045)) + ok 69 - mp_next(mp_encode(2.718281828459045)) + ok 70 - mp_decode(mp_encode(2.718281828459045) len + ok 71 - mp_decode(mp_encode(2.718281828459045)) value + ok 72 - mp_decode(mp_encode(2.718281828459045)) scale + ok 73 - str(mp_decode(mp_encode(2.718281828459045))) == 2.718281828459045 + ok 74 - mp_ext_type is MP_DECIMAL + ok 75 - decimal_unpack() after mp_decode_extl() + ok 76 - decimal_unpack() after mp_decode_extl() value + ok 77 - decimal_unpack() after mp_decode_extl() len + ok 78 - mp_sizeof_decimal(-2.718281828459045) + ok 79 - mp_sizeof_decimal(-2.718281828459045) == len(mp_encode_decimal(-2.718281828459045)) + ok 80 - mp_next(mp_encode(-2.718281828459045)) + ok 81 - mp_decode(mp_encode(-2.718281828459045) len + ok 82 - mp_decode(mp_encode(-2.718281828459045)) value + ok 83 - mp_decode(mp_encode(-2.718281828459045)) scale + ok 84 - str(mp_decode(mp_encode(-2.718281828459045))) == -2.718281828459045 + ok 85 - mp_ext_type is MP_DECIMAL + ok 86 - decimal_unpack() after mp_decode_extl() + ok 87 - decimal_unpack() after mp_decode_extl() value + ok 88 - decimal_unpack() after mp_decode_extl() len + ok 89 - mp_sizeof_decimal(3.141592653589793) + ok 90 - mp_sizeof_decimal(3.141592653589793) == len(mp_encode_decimal(3.141592653589793)) + ok 91 - mp_next(mp_encode(3.141592653589793)) + ok 92 - mp_decode(mp_encode(3.141592653589793) len + ok 93 - mp_decode(mp_encode(3.141592653589793)) value + ok 94 - mp_decode(mp_encode(3.141592653589793)) scale + ok 95 - str(mp_decode(mp_encode(3.141592653589793))) == 3.141592653589793 + ok 96 - mp_ext_type is MP_DECIMAL + ok 97 - decimal_unpack() after mp_decode_extl() + ok 98 - decimal_unpack() after mp_decode_extl() value + ok 99 - decimal_unpack() after mp_decode_extl() len + ok 100 - mp_sizeof_decimal(-3.141592653589793) + ok 101 - mp_sizeof_decimal(-3.141592653589793) == len(mp_encode_decimal(-3.141592653589793)) + ok 102 - mp_next(mp_encode(-3.141592653589793)) + ok 103 - mp_decode(mp_encode(-3.141592653589793) len + ok 104 - mp_decode(mp_encode(-3.141592653589793)) value + ok 105 - mp_decode(mp_encode(-3.141592653589793)) scale + ok 106 - str(mp_decode(mp_encode(-3.141592653589793))) == -3.141592653589793 + ok 107 - mp_ext_type is MP_DECIMAL + ok 108 - decimal_unpack() after mp_decode_extl() + ok 109 - decimal_unpack() after mp_decode_extl() value + ok 110 - decimal_unpack() after mp_decode_extl() len + ok 111 - mp_sizeof_decimal(1234567891234567890.0987654321987654321) + ok 112 - mp_sizeof_decimal(1234567891234567890.0987654321987654321) == len(mp_encode_decimal(1234567891234567890.0987654321987654321)) + ok 113 - mp_next(mp_encode(1234567891234567890.0987654321987654321)) + ok 114 - mp_decode(mp_encode(1234567891234567890.0987654321987654321) len + ok 115 - mp_decode(mp_encode(1234567891234567890.0987654321987654321)) value + ok 116 - mp_decode(mp_encode(1234567891234567890.0987654321987654321)) scale + ok 117 - str(mp_decode(mp_encode(1234567891234567890.0987654321987654321))) == 1234567891234567890.0987654321987654321 + ok 118 - mp_ext_type is MP_DECIMAL + ok 119 - decimal_unpack() after mp_decode_extl() + ok 120 - decimal_unpack() after mp_decode_extl() value + ok 121 - decimal_unpack() after mp_decode_extl() len + ok 122 - mp_sizeof_decimal(-1234567891234567890.0987654321987654321) + ok 123 - mp_sizeof_decimal(-1234567891234567890.0987654321987654321) == len(mp_encode_decimal(-1234567891234567890.0987654321987654321)) + ok 124 - mp_next(mp_encode(-1234567891234567890.0987654321987654321)) + ok 125 - mp_decode(mp_encode(-1234567891234567890.0987654321987654321) len + ok 126 - mp_decode(mp_encode(-1234567891234567890.0987654321987654321)) value + ok 127 - mp_decode(mp_encode(-1234567891234567890.0987654321987654321)) scale + ok 128 - str(mp_decode(mp_encode(-1234567891234567890.0987654321987654321))) == -1234567891234567890.0987654321987654321 + ok 129 - mp_ext_type is MP_DECIMAL + ok 130 - decimal_unpack() after mp_decode_extl() + ok 131 - decimal_unpack() after mp_decode_extl() value + ok 132 - decimal_unpack() after mp_decode_extl() len + ok 133 - mp_sizeof_decimal(0.0000000000000000000000000000000000001) + ok 134 - mp_sizeof_decimal(0.0000000000000000000000000000000000001) == len(mp_encode_decimal(0.0000000000000000000000000000000000001)) + ok 135 - mp_next(mp_encode(0.0000000000000000000000000000000000001)) + ok 136 - mp_decode(mp_encode(0.0000000000000000000000000000000000001) len + ok 137 - mp_decode(mp_encode(0.0000000000000000000000000000000000001)) value + ok 138 - mp_decode(mp_encode(0.0000000000000000000000000000000000001)) scale + ok 139 - str(mp_decode(mp_encode(0.0000000000000000000000000000000000001))) == 0.0000000000000000000000000000000000001 + ok 140 - mp_ext_type is MP_DECIMAL + ok 141 - decimal_unpack() after mp_decode_extl() + ok 142 - decimal_unpack() after mp_decode_extl() value + ok 143 - decimal_unpack() after mp_decode_extl() len + ok 144 - mp_sizeof_decimal(-0.0000000000000000000000000000000000001) + ok 145 - mp_sizeof_decimal(-0.0000000000000000000000000000000000001) == len(mp_encode_decimal(-0.0000000000000000000000000000000000001)) + ok 146 - mp_next(mp_encode(-0.0000000000000000000000000000000000001)) + ok 147 - mp_decode(mp_encode(-0.0000000000000000000000000000000000001) len + ok 148 - mp_decode(mp_encode(-0.0000000000000000000000000000000000001)) value + ok 149 - mp_decode(mp_encode(-0.0000000000000000000000000000000000001)) scale + ok 150 - str(mp_decode(mp_encode(-0.0000000000000000000000000000000000001))) == -0.0000000000000000000000000000000000001 + ok 151 - mp_ext_type is MP_DECIMAL + ok 152 - decimal_unpack() after mp_decode_extl() + ok 153 - decimal_unpack() after mp_decode_extl() value + ok 154 - decimal_unpack() after mp_decode_extl() len + ok 155 - mp_sizeof_decimal(0.00000000000000000000000000000000000001) + ok 156 - mp_sizeof_decimal(0.00000000000000000000000000000000000001) == len(mp_encode_decimal(0.00000000000000000000000000000000000001)) + ok 157 - mp_next(mp_encode(0.00000000000000000000000000000000000001)) + ok 158 - mp_decode(mp_encode(0.00000000000000000000000000000000000001) len + ok 159 - mp_decode(mp_encode(0.00000000000000000000000000000000000001)) value + ok 160 - mp_decode(mp_encode(0.00000000000000000000000000000000000001)) scale + ok 161 - str(mp_decode(mp_encode(0.00000000000000000000000000000000000001))) == 0.00000000000000000000000000000000000001 + ok 162 - mp_ext_type is MP_DECIMAL + ok 163 - decimal_unpack() after mp_decode_extl() + ok 164 - decimal_unpack() after mp_decode_extl() value + ok 165 - decimal_unpack() after mp_decode_extl() len + ok 166 - mp_sizeof_decimal(-0.00000000000000000000000000000000000001) + ok 167 - mp_sizeof_decimal(-0.00000000000000000000000000000000000001) == len(mp_encode_decimal(-0.00000000000000000000000000000000000001)) + ok 168 - mp_next(mp_encode(-0.00000000000000000000000000000000000001)) + ok 169 - mp_decode(mp_encode(-0.00000000000000000000000000000000000001) len + ok 170 - mp_decode(mp_encode(-0.00000000000000000000000000000000000001)) value + ok 171 - mp_decode(mp_encode(-0.00000000000000000000000000000000000001)) scale + ok 172 - str(mp_decode(mp_encode(-0.00000000000000000000000000000000000001))) == -0.00000000000000000000000000000000000001 + ok 173 - mp_ext_type is MP_DECIMAL + ok 174 - decimal_unpack() after mp_decode_extl() + ok 175 - decimal_unpack() after mp_decode_extl() value + ok 176 - decimal_unpack() after mp_decode_extl() len + ok 177 - mp_sizeof_decimal(99999999999999999999999999999999999999) + ok 178 - mp_sizeof_decimal(99999999999999999999999999999999999999) == len(mp_encode_decimal(99999999999999999999999999999999999999)) + ok 179 - mp_next(mp_encode(99999999999999999999999999999999999999)) + ok 180 - mp_decode(mp_encode(99999999999999999999999999999999999999) len + ok 181 - mp_decode(mp_encode(99999999999999999999999999999999999999)) value + ok 182 - mp_decode(mp_encode(99999999999999999999999999999999999999)) scale + ok 183 - str(mp_decode(mp_encode(99999999999999999999999999999999999999))) == 99999999999999999999999999999999999999 + ok 184 - mp_ext_type is MP_DECIMAL + ok 185 - decimal_unpack() after mp_decode_extl() + ok 186 - decimal_unpack() after mp_decode_extl() value + ok 187 - decimal_unpack() after mp_decode_extl() len + ok 188 - mp_sizeof_decimal(-99999999999999999999999999999999999999) + ok 189 - mp_sizeof_decimal(-99999999999999999999999999999999999999) == len(mp_encode_decimal(-99999999999999999999999999999999999999)) + ok 190 - mp_next(mp_encode(-99999999999999999999999999999999999999)) + ok 191 - mp_decode(mp_encode(-99999999999999999999999999999999999999) len + ok 192 - mp_decode(mp_encode(-99999999999999999999999999999999999999)) value + ok 193 - mp_decode(mp_encode(-99999999999999999999999999999999999999)) scale + ok 194 - str(mp_decode(mp_encode(-99999999999999999999999999999999999999))) == -99999999999999999999999999999999999999 + ok 195 - mp_ext_type is MP_DECIMAL + ok 196 - decimal_unpack() after mp_decode_extl() + ok 197 - decimal_unpack() after mp_decode_extl() value + ok 198 - decimal_unpack() after mp_decode_extl() len +ok 280 - subtests -- 2.20.1 (Apple Git-117)