Cpanel-JSON-XS
view release on metacpan or search on metacpan
and Math::BigFloat objects with allow_bignum. (#147 by Pali)
- Fix encoding floating point values above 2^64 in PV slot to JSON_TYPE_INT
(#148, #150 by Pali)
- Do not allow serializing objects when convert_blessed is not enabled.
(#146 by Pali)
4.12 2019-06-11 (rurban)
- Make encoder independent on Math::BigInt version (#140 by Pali)
- Rethrow error from eval_sv and eval_pv() (#138, #139 by Pali),
e.g. when Math::BigInt/BigFloat fails.
- Fix encoding Inf and NaN from PV and NV slots to JSON_TYPE_INT
(#137 by Pali)
- Fix memory corruption in sv_to_ivuv() function (#136 by Pali)
- Add new method ->require_types (#135 by Pali)
- Fix typed json encoder conversion from scalar's PV and NV slot to
JSON_TYPE_INT (#133, #134 by Pali)
- Fix inconsistency with warnings in typed json encoder (#131 by Pali)
- Fix Perl 5.8.0 support (#130 by Pali)
- Fixed minor pod typo (#129 by sheeit)
- Document invalid recursive callbacks or overloads (#128)
- Fix overloaded eq/ne comparisons (GH #116 by demerphq, GH #117 by Graham Knopp):
detect strings, protect from endless recursion. false is now ne "True".
clarify eq/ne rules in the docs.
4.05 2018-08-19 (rurban)
- Set decoded type (PR #115 by Pali)
- Add json_type_weaken (PR #114 by Pali)
- Fix tests for 5.6 (rurban, pali)
4.04 2018-06-22 (rurban)
- Fix bignum NaN/inf handling (#78 reported by Slaven Rezic)
- Move author tests to xt/ as suggested in #106, added a make xtest target.
Fixes a test fail with ASAN.
4.03 2018-06-21 (rurban)
- Add sereal cpanel_json_xs type (#110 James Rouzier)
- Fix bencode/bdecode methods in cpanel_json_xs (#111 Fulvio Scapin)
- Overload ne operator for JSON::PP::Boolean (#107 tevfik1903)
- Add a missing semicolon to a documentation example (#104 E. Choroba)
4.02 2018-02-27 (rurban)
t/test_parsing/n_array_unclosed_with_object_inside.json
t/test_parsing/n_incomplete_false.json
t/test_parsing/n_incomplete_null.json
t/test_parsing/n_incomplete_true.json
t/test_parsing/n_number_++.json
t/test_parsing/n_number_+1.json
t/test_parsing/n_number_+Inf.json
t/test_parsing/n_number_-01.json
t/test_parsing/n_number_-1.0..json
t/test_parsing/n_number_-2..json
t/test_parsing/n_number_-NaN.json
t/test_parsing/n_number_.-1.json
t/test_parsing/n_number_.2e-3.json
t/test_parsing/n_number_0.1.2.json
t/test_parsing/n_number_0.3e+.json
t/test_parsing/n_number_0.3e.json
t/test_parsing/n_number_0.e1.json
t/test_parsing/n_number_0_capital_E+.json
t/test_parsing/n_number_0_capital_E.json
t/test_parsing/n_number_0e+.json
t/test_parsing/n_number_0e.json
t/test_parsing/n_number_1.0e+.json
t/test_parsing/n_number_1.0e-.json
t/test_parsing/n_number_1.0e.json
t/test_parsing/n_number_1_000.json
t/test_parsing/n_number_1eE2.json
t/test_parsing/n_number_2.e+3.json
t/test_parsing/n_number_2.e-3.json
t/test_parsing/n_number_2.e3.json
t/test_parsing/n_number_9.e+.json
t/test_parsing/n_number_Inf.json
t/test_parsing/n_number_NaN.json
t/test_parsing/n_number_U+FF11_fullwidth_digit_one.json
t/test_parsing/n_number_expression.json
t/test_parsing/n_number_hex_1_digit.json
t/test_parsing/n_number_hex_2_digits.json
t/test_parsing/n_number_infinity.json
t/test_parsing/n_number_invalid+-.json
t/test_parsing/n_number_invalid-negative-real.json
t/test_parsing/n_number_invalid-utf-8-in-bigger-int.json
t/test_parsing/n_number_invalid-utf-8-in-exponent.json
t/test_parsing/n_number_invalid-utf-8-in-int.json
You can force the type to be a JSON number by numifying it:
my $x = "3"; # some variable containing a string
$x += 0; # numify it, ensuring it will be dumped as a number
$x *= 1; # same thing, the choice is yours.
Note that numerical precision has the same meaning as under Perl (so
binary to decimal conversion follows the same rules as in Perl,
which can differ to other languages). Also, your perl interpreter
might expose extensions to the floating point numbers of your
platform, such as infinities or NaN's - these cannot be represented
in JSON, and thus null is returned instead. Optionally you can
configure it to stringify inf and nan values.
OBJECT SERIALIZATION
As JSON cannot directly represent Perl objects, you have to choose
between a pure JSON representation (without the ability to deserialize
the object automatically again), and a nonstandard extension to the JSON
syntax, tagged values.
SERIALIZATION
SHA256 903dda41bec7150e805f158ac061587fcf72b9d01d15b86222966814dda496f0 t/test_parsing/n_array_unclosed_with_object_inside.json
SHA256 7d00bafe4b8765a9c80f8c1db638ad802d0214599d3caa0ea977f26ea01fb4e5 t/test_parsing/n_incomplete_false.json
SHA256 267620ed5987a977c03473eee18b9aa69a4183b3024417f93466983b7c772491 t/test_parsing/n_incomplete_null.json
SHA256 5f5470d03cb2af3cce0cf3cc063ba8ae676258cb9d4ba0dcfc82a978ab5f40ba t/test_parsing/n_incomplete_true.json
SHA256 ec5e5041e992f94073df8faeeb6b9c97b3ee53b7384234beaa7595b424e346b6 t/test_parsing/n_number_++.json
SHA256 d83017afc0b63eef28670ae0c39391f0fabe91f299126160029a13713fca361e t/test_parsing/n_number_+1.json
SHA256 5d61f171f20d3267ab360f545a50e55f462ca45ff5d067fd51678f71c4cfa7ab t/test_parsing/n_number_+Inf.json
SHA256 e3216a79fdad284c5d70f8218c81b85562c05b3427d7e7932b151b68a9311519 t/test_parsing/n_number_-01.json
SHA256 baab147e06a9082026c6292240e4c8802c05a70de0da085bc6d3e07765243757 t/test_parsing/n_number_-1.0..json
SHA256 bc47f88e8caae073ad2bd956036332513a25ef55da8eb7637347677c2a230297 t/test_parsing/n_number_-2..json
SHA256 f7df6eb96bdb9858395509fd4536c544eda9fabcbb49b74941da50eca7228c6c t/test_parsing/n_number_-NaN.json
SHA256 3c7791891957c90087cea4ec2483fdf1518d1a5717210b9853c08332cedd2735 t/test_parsing/n_number_.-1.json
SHA256 d2c89dd9ae3a6a5c01b64bb6f82055a35a0d79a084668f579177e1ef6242ba37 t/test_parsing/n_number_.2e-3.json
SHA256 46d28bfddb89134f2219c3f18734c5e625cff94d92ff3e2caf9e5904545c8099 t/test_parsing/n_number_0.1.2.json
SHA256 d56c36978bba5b6f062b28f35f7e237af4f0fe016edb2943e666da6e58efedf1 t/test_parsing/n_number_0.3e+.json
SHA256 0791dee428d1d6a1fbc6eb26c2cc745f4eee2c89e8c20a6bc5d58f6ea7a859e5 t/test_parsing/n_number_0.3e.json
SHA256 379c8b8c643d0ce35b907d0d1dcd4780f586badae64c42d78cd05048b1879707 t/test_parsing/n_number_0.e1.json
SHA256 cd14bf1fa8803ada52504f5a88bb1b3bf703234bdcc3977610c50410582f5f49 t/test_parsing/n_number_0_capital_E+.json
SHA256 a6fab5fbe2ef3fe441d68c14301fc85048286e68c6bba7a93f643d788b6cf081 t/test_parsing/n_number_0_capital_E.json
SHA256 3f54bdbbd4e3ad547fa457b5810df7c96f2d2c3bc6985e11202ffd1d42116889 t/test_parsing/n_number_0e+.json
SHA256 cd279aa777afca083b346dbc2b62a1847c24f1556b619b7564842457f8949c93 t/test_parsing/n_number_0e.json
SHA256 0937993255ba3ce388b6109abbb081d3740075dd4efcab01b4b2c11c8c84fd19 t/test_parsing/n_number_1.0e+.json
SHA256 64b715b632ad55a49b6221cb15f6827d7e4630a83baed3713939f31170e63afb t/test_parsing/n_number_1.0e-.json
SHA256 1b45efc13b6f4321c799e46e9304b31449719274bcd5d4e9e959c2d828c54eba t/test_parsing/n_number_1.0e.json
SHA256 6713fc40db65bdbedf52f0ebe3a3121435ab186dcb11b408cb5a3ce9ed000f38 t/test_parsing/n_number_1_000.json
SHA256 02b51b6940228135be8c48f0472f220a341a9b7bce8150395a58afb7e41fac18 t/test_parsing/n_number_1eE2.json
SHA256 ddfb52b4d5c947c90b7b62e4a654c35f6c3a4b726ef606da6b6fdb1aeb0ed33d t/test_parsing/n_number_2.e+3.json
SHA256 ceb6bf65dbdcb4c6dc85156d0646d095784445db6c84f594353e249491caf02c t/test_parsing/n_number_2.e-3.json
SHA256 f1c8e1ff48fe7daafbad0cc9f3e3ca21960e06292f7553e1d25f845abc8f26d9 t/test_parsing/n_number_2.e3.json
SHA256 8e33de781a327a6563cbd4d808cabfdb6e3ad2b2ea916de34f8ad2f11e0d0801 t/test_parsing/n_number_9.e+.json
SHA256 68979a7a850577548cffccc18abe34fab7d70d4e733b10ae228e030a142052e5 t/test_parsing/n_number_Inf.json
SHA256 638577393ecb248f472c18a1a95104181a3188551615d763873393eaf4eff186 t/test_parsing/n_number_NaN.json
SHA256 418b3fc29c6688ee9fe090022ad1cd422ac738d8b5ce13a9272cf7451a340c6c t/test_parsing/n_number_U+FF11_fullwidth_digit_one.json
SHA256 bb9856e4c612b9ed993f6520936bcc560cbf3bf112000f28c62ed3a787db983d t/test_parsing/n_number_expression.json
SHA256 37d7fe7b45e87c632936ce095616eacc75fa292fffa1581dbc0682bfb9e102a2 t/test_parsing/n_number_hex_1_digit.json
SHA256 ce2e3b8b3e0a6cf29602463d4e70910d3b3fcb38874800d491efe163d8ff9592 t/test_parsing/n_number_hex_2_digits.json
SHA256 10058b8cd98a02ff73d5cd3092bb44f05b0d11148d0a81fde35c2a90673f1254 t/test_parsing/n_number_infinity.json
SHA256 25981c42fdd25646ab17d57bfaa65e4b2d7b791fdf13840e75c5a9e8f66dec70 t/test_parsing/n_number_invalid+-.json
SHA256 5ba01dae4b0ab597e21ee7a321a2793a5a4bf0acd5d535e0e6ed261c3f584d4a t/test_parsing/n_number_invalid-negative-real.json
SHA256 c5efd0312f655f7d8a15938fed77cea804726f6ce9539cd73340616e151e1338 t/test_parsing/n_number_invalid-utf-8-in-bigger-int.json
SHA256 58cc9aadeb3f0619fda566c1d439e02d94722663ac388822ac3155f5dd3a397e t/test_parsing/n_number_invalid-utf-8-in-exponent.json
SHA256 72258704dd857e84f0aa55e7124204d0dcf78247472d314310de0b023cb9b8f2 t/test_parsing/n_number_invalid-utf-8-in-int.json
You can force the type to be a JSON number by numifying it:
my $x = "3"; # some variable containing a string
$x += 0; # numify it, ensuring it will be dumped as a number
$x *= 1; # same thing, the choice is yours.
Note that numerical precision has the same meaning as under Perl (so
binary to decimal conversion follows the same rules as in Perl, which
can differ to other languages). Also, your perl interpreter might expose
extensions to the floating point numbers of your platform, such as
infinities or NaN's - these cannot be represented in JSON, and thus
null is returned instead. Optionally you can configure it to stringify
inf and nan values.
=back
=head2 OBJECT SERIALIZATION
As JSON cannot directly represent Perl objects, you have to choose between
a pure JSON representation (without the ability to deserialize the object
automatically again), and a nonstandard extension to the JSON syntax,
#define STR_NAN "nan"
#define STR_QNAN "nan(ind)"
/* old standard msvcrt.dll */
#define STR_INF3 "1.#INF"
#define STR_INF4 "1.#INF.0"
#define STR_NAN2 "1.#IND"
#define STR_QNAN2 "1.#QNAN"
#define HAVE_QNAN
#elif defined(sun) || defined(__sun)
#define STR_INF "Infinity"
#define STR_NAN "NaN"
#elif defined(__hpux)
#define STR_INF "++"
#define STR_NAN "-?"
#define HAVE_NEG_NAN
#define STR_NEG_INF "---"
#define STR_NEG_NAN "?"
#elif defined(_AIX) || defined(_AIX50)
/* xlC compiler: __TOS_AIX__ FIXME: This does not work yet. GH #165 */
#define STR_INF "INF"
#define STR_INF2 "INF.0"
#define HAVE_NEG_NAN
#define STR_NEG_INF "-INF"
#define HAVE_NEG_NAN
#define HAVE_QNAN
#define STR_NAN "NaN"
#define STR_QNAN "NaNQ"
//#define STR_QNAN "NANQ"
#else
#define STR_INF "inf"
#define STR_NAN "nan"
#endif
/* NV_INF compatibility for Perl 5.6 */
#if !defined(NV_INF) && defined(USE_LONG_DOUBLE) && defined(LDBL_INFINITY)
# define NV_INF LDBL_INFINITY
#endif
return;
}
SvREFCNT_dec(rv);
}
}
if (UNLIKELY(isref == 1
&& (enc->json.flags & F_ALLOW_BIGNUM) && str && str[0] == '+')) {
str++;
len--;
}
/* if ALLOW_BIGNUM and Math::Big* and NaN => according to stringify_infnan */
if (UNLIKELY(
(enc->json.flags & F_ALLOW_BIGNUM)
&& str
&& SvROK(sv)
&& (memEQc(str, "NaN") || memEQc(str, "nan") ||
memEQc(str, "inf") || memEQc(str, "-inf"))))
{
if (is_bignum_obj (aTHX_ SvRV (sv)))
{
if (enc->json.infnan_mode == 0) {
encode_const_str (aTHX_ enc, "null", 4, 0);
if (pv) SvREFCNT_dec(pv);
return;
} else if (enc->json.infnan_mode == 3) {
if (memEQc(str, "NaN") || memEQc(str, "nan"))
encode_const_str (aTHX_ enc, "nan", 3, 0);
else if (memEQc(str, "inf"))
encode_const_str (aTHX_ enc, "inf", 3, 0);
else
encode_const_str (aTHX_ enc, "-inf", 4, 0);
if (pv) SvREFCNT_dec(pv);
return;
}
}
}
if (UNLIKELY (is_bigobj))
{
STRLEN len;
char *str = SvPV_nomg (sv, len);
if (UNLIKELY (str[0] == '+'))
{
str++;
len--;
}
if (UNLIKELY (memEQc (str, "NaN") || memEQc (str, "nan")))
{
nv = NV_NAN;
is_bigobj = 0;
}
else if (UNLIKELY (memEQc (str, "inf")))
{
nv = NV_INF;
is_bigobj = 0;
}
else if (UNLIKELY (memEQc (str, "-inf")))
PUTBACK;
}
str = SvPV_nomg (sv, len);
if (UNLIKELY (str[0] == '+'))
{
str++;
len--;
}
if (UNLIKELY (strEQc (str, "NaN") || strEQc (str, "nan")))
{
encode_const_str (aTHX_ enc, "0", 1, 0);
}
else if (UNLIKELY (strEQc (str, "inf")))
{
need (aTHX_ enc, IVUV_MAXCHARS);
savecur = enc->cur;
saveend = enc->end;
enc->cur += snprintf (enc->cur, IVUV_MAXCHARS, "%" UVuf, UV_MAX);
}
return;
}
else if (!(numtype & (IS_NUMBER_IN_UV|IS_NUMBER_INFINITY|IS_NUMBER_NAN)))
{
sv_to_ivuv (aTHX_ sv, &is_neg, &iv, &uv);
}
}
else
{
#if PERL_VERSION < 8
/* SvIV() and SvUV() in Perl 5.6 does not handle Inf and NaN in NV slot */
if (SvNOKp (sv) && UNLIKELY (isinf (SvNVX (sv))))
{
if (SvNVX (sv) < 0)
{
is_neg = 1;
iv = IV_MIN;
uv = (UV)iv;
}
else
{
s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
s++; if (s < send && (*s == 'I' || *s == 'i')) {
s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
s++;
}
sawinf = 1;
} else if (*s == 'N' || *s == 'n') {
/* XXX TODO: There are signaling NaNs and quiet NaNs. */
s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
s++;
sawnan = 1;
} else
return 0;
if (sawinf) {
numtype &= IS_NUMBER_NEG; /* Keep track of sign */
numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;
t/110_bignum.t view on Meta::CPAN
0,
'decode bigint inside structure'
) or Dump($num);
$num = $json->decode(q|[2.0000000000000000001]|)->[0];
isa_ok( $num, 'Math::BigFloat' );
is( "$num", '2.0000000000000000001', 'decode bigfloat inside structure' )
or Dump $num;
my $bignan = Math::BigInt->new("NaN");
my $nan = $json->encode($bignan);
is( "$nan", 'null', 'nan default' );
$nan = $json->stringify_infnan(0)->encode($bignan);
is( "$nan", 'null', 'nan null' );
$nan = $json->stringify_infnan(3)->encode($bignan);
is( "$nan", 'nan', 'nan stringify' );
my $biginf = Math::BigInt->new("Inf");
#note $biginf;
my $inf = $json->stringify_infnan(0)->encode($biginf);
t/117_numbers.t view on Meta::CPAN
is encode_json([9**9**9/9**9**9]), '[null]', "-nan -> null";
# infnan_mode = 1: # platform specific strings
my $json = Cpanel::JSON::XS->new->stringify_infnan;
my $have_qnan = ($^O eq 'MSWin32' || $^O eq 'aix') ? 1 : 0;
# TODO dec_osf
# variants as in t/op/infnan.t
my (@inf, @neg_inf, @nan, @neg_nan);
my ($inf, $nan) =
($^O eq 'MSWin32') ? ('1.#INF','1.#QNAN') :
($^O eq 'solaris') ? ('Infinity','NaN') :
($^O eq 'aix') ? ('INF','NaNQ') :
($^O eq 'hpux') ? ('++','-?') :
('inf','nan');
my $neg_nan =
($^O eq 'MSWin32') ? "-1.#IND" :
($^O eq 'hpux') ? "?" :
"-".$nan;
my $neg_inf =
($^O eq 'hpux') ? "---" :
"-".$inf;
t/118_type.t view on Meta::CPAN
is($cjson->encode(Cpanel::JSON::XS::true, JSON_TYPE_STRING), '"true"');
is($cjson->encode(Cpanel::JSON::XS::true, json_type_anyof([], {}, JSON_TYPE_BOOL)), 'true');
is($cjson->encode(undef, JSON_TYPE_BOOL_OR_NULL), 'null');
is($cjson->encode(undef, JSON_TYPE_INT_OR_NULL), 'null');
is($cjson->encode(undef, JSON_TYPE_FLOAT_OR_NULL), 'null');
is($cjson->encode(undef, JSON_TYPE_STRING_OR_NULL), 'null');
is($cjson->encode(undef, json_type_null_or_anyof([])), 'null');
is($cjson->encode(undef, json_type_null_or_anyof({})), 'null');
is($cjson->encode(int("NaN"), JSON_TYPE_INT), '0');
is($cjson->encode('NaN', JSON_TYPE_INT), '0');
if ($Config{ivsize} == 4) {
# values around signed IV_MAX should work correctly as they can be represented by unsigned UV
is($cjson->encode( '2147483646', JSON_TYPE_INT), '2147483646'); # 2^31-2
is($cjson->encode( '2147483647', JSON_TYPE_INT), '2147483647'); # 2^31-1
is($cjson->encode( '2147483648', JSON_TYPE_INT), '2147483648'); # 2^31
is($cjson->encode( '2147483649', JSON_TYPE_INT), '2147483649'); # 2^31+1
is($cjson->encode( '2147483650', JSON_TYPE_INT), '2147483650'); # 2^31+2
# values up to signed IV_MIN should work correctly too
t/118_type.t view on Meta::CPAN
SKIP: {
skip 'requires Math::BigInt', 8 unless eval { require Math::BigInt };
# Math::BigInt values outside of range [IV_MIN, UV_MAX] with enabled bignum
is($bigcjson->encode(Math::BigInt->new('18446744073709551616'), JSON_TYPE_INT), '18446744073709551616'); # 2^64
is($bigcjson->encode(Math::BigInt->new('18446744073709551617'), JSON_TYPE_INT), '18446744073709551617'); # 2^64+1
is($bigcjson->encode(Math::BigInt->new('18446744073709551618'), JSON_TYPE_INT), '18446744073709551618'); # 2^64+2
is($bigcjson->encode(Math::BigInt->new('-9223372036854775809'), JSON_TYPE_INT), '-9223372036854775809'); # -2^63-1
is($bigcjson->encode(Math::BigInt->new('-9223372036854775810'), JSON_TYPE_INT), '-9223372036854775810'); # -2^63-2
is($bigcjson->encode(Math::BigInt->new('NaN'), JSON_TYPE_INT), '0');
if ($Config{ivsize} == 4) {
is($bigcjson->encode(Math::BigInt->new('+inf'), JSON_TYPE_INT), '4294967295');
is($bigcjson->encode(Math::BigInt->new('-inf'), JSON_TYPE_INT), '-2147483648');
} elsif ($Config{ivsize} == 8 && $] > 5.008) {
is($bigcjson->encode(Math::BigInt->new('+inf'), JSON_TYPE_INT), '18446744073709551615');
is($bigcjson->encode(Math::BigInt->new('-inf'), JSON_TYPE_INT), '-9223372036854775808');
} else {
skip "unknown ivsize $Config{ivsize} or too old", 2;
}
t/118_type.t view on Meta::CPAN
SKIP: {
skip 'requires Math::BigFloat 1.16', 8 unless eval { require Math::BigFloat; Math::BigFloat->VERSION(1.16) };
# Math::BigFloat values outside of range [IV_MIN, UV_MAX] with enabled bignum
is($bigcjson->encode(Math::BigFloat->new('18446744073709551616.5'), JSON_TYPE_INT), '18446744073709551616'); # 2^64
is($bigcjson->encode(Math::BigFloat->new('18446744073709551617.5'), JSON_TYPE_INT), '18446744073709551617'); # 2^64+1
is($bigcjson->encode(Math::BigFloat->new('18446744073709551618.5'), JSON_TYPE_INT), '18446744073709551618'); # 2^64+2
is($bigcjson->encode(Math::BigFloat->new('-9223372036854775809.5'), JSON_TYPE_INT), '-9223372036854775809'); # -2^63-1
is($bigcjson->encode(Math::BigFloat->new('-9223372036854775810.5'), JSON_TYPE_INT), '-9223372036854775810'); # -2^63-2
is($bigcjson->encode(Math::BigFloat->new('NaN'), JSON_TYPE_INT), '0');
if ($Config{ivsize} == 4) {
is($bigcjson->encode(Math::BigFloat->new('+inf'), JSON_TYPE_INT), '4294967295');
is($bigcjson->encode(Math::BigFloat->new('-inf'), JSON_TYPE_INT), '-2147483648');
} elsif ($Config{ivsize} == 8) {
is($bigcjson->encode(Math::BigFloat->new('+inf'), JSON_TYPE_INT), '18446744073709551615');
is($bigcjson->encode(Math::BigFloat->new('-inf'), JSON_TYPE_INT), '-9223372036854775808');
} else {
skip "unknown ivsize $Config{ivsize}", 2;
}
}
my $fltinf;
if ($Config{nvtype} eq 'long double' &&
(exists $Config{longdblkind}
? $Config{longdblkind} == 3
: $Config{archname} =~ /86/)) {
$fltinf = '1.18973149535723177e+4932';
} elsif ($Config{nvtype} eq 'double' && $Config{nvsize} == 8) {
$fltinf = '1.79769313486232e+308';
}
is($cjson->encode( int("NaN"), JSON_TYPE_FLOAT), '0.0');
is($cjson->encode( 'NaN', JSON_TYPE_FLOAT), '0.0');
SKIP: {
skip "unknown nvtype $Config{nvtype}, " .
exists $Config{longdblkind} ? "longdblkind $Config{longdblkind}" : "", 6
unless $fltinf;
is($cjson->encode( int( 'Inf'), JSON_TYPE_FLOAT), ($] >= 5.008 && $] < 5.008008) ? '0.0' : $fltinf);
is($cjson->encode( int('-Inf'), JSON_TYPE_FLOAT), ($] >= 5.008 && $] < 5.008008) ? '0.0' : "-$fltinf");
is($cjson->encode( 'Inf', JSON_TYPE_FLOAT), $fltinf);
is($cjson->encode( '-Inf', JSON_TYPE_FLOAT), "-$fltinf");
is($cjson->encode( 9**9**9, JSON_TYPE_FLOAT), $fltinf);
is($cjson->encode( -9**9**9, JSON_TYPE_FLOAT), "-$fltinf");
}
SKIP: {
skip 'requires Math::BigFloat', 20 unless eval { require Math::BigFloat };
skip 'unknown NV_MAX', 20 if !$fltinf;
skip 'too old', 20 if $] < 5.008;
is($bigcjson->encode( int("NaN"), JSON_TYPE_FLOAT), '0.0');
is($bigcjson->encode( 'NaN', JSON_TYPE_FLOAT), '0.0');
is($bigcjson->encode( int( 'Inf'), JSON_TYPE_FLOAT), ($] >= 5.008 && $] < 5.008008) ? '0.0' : $fltinf);
is($bigcjson->encode( int('-Inf'), JSON_TYPE_FLOAT), ($] >= 5.008 && $] < 5.008008) ? '0.0' : "-$fltinf");
is($bigcjson->encode( 'Inf', JSON_TYPE_FLOAT), $fltinf);
is($bigcjson->encode( '-Inf', JSON_TYPE_FLOAT), "-$fltinf");
is($bigcjson->encode( 9**9**9, JSON_TYPE_FLOAT), $fltinf);
is($bigcjson->encode( -9**9**9, JSON_TYPE_FLOAT), "-$fltinf");
# integer string values outside of range [IV_MIN, UV_MAX] with enabled bignum
is($bigcjson->encode('18446744073709551616', JSON_TYPE_FLOAT), '18446744073709551616.0'); # 2^64
is($bigcjson->encode('18446744073709551617', JSON_TYPE_FLOAT), '18446744073709551617.0'); # 2^64+1
t/118_type.t view on Meta::CPAN
unless $fltinf;
skip 'too old', 8 if $] < 5.008;
# Math::BigInt values with enabled bignum
is($bigcjson->encode(Math::BigInt->new('18446744073709551616'), JSON_TYPE_FLOAT), '18446744073709551616.0'); # 2^64
is($bigcjson->encode(Math::BigInt->new('18446744073709551617'), JSON_TYPE_FLOAT), '18446744073709551617.0'); # 2^64+1
is($bigcjson->encode(Math::BigInt->new('18446744073709551618'), JSON_TYPE_FLOAT), '18446744073709551618.0'); # 2^64+2
is($bigcjson->encode(Math::BigInt->new('-9223372036854775809'), JSON_TYPE_FLOAT), '-9223372036854775809.0'); # -2^63-1
is($bigcjson->encode(Math::BigInt->new('-9223372036854775810'), JSON_TYPE_FLOAT), '-9223372036854775810.0'); # -2^63-2
is($bigcjson->encode(Math::BigInt->new('NaN'), JSON_TYPE_FLOAT), '0.0');
is($bigcjson->encode(Math::BigInt->new('+inf'), JSON_TYPE_FLOAT), $fltinf);
is($bigcjson->encode(Math::BigInt->new('-inf'), JSON_TYPE_FLOAT), "-$fltinf");
}
SKIP: {
skip 'requires Math::BigFloat', 8 unless eval { require Math::BigFloat };
skip "unknown nvtype $Config{nvtype}, longdblkind $Config{longdblkind}", 8
unless $fltinf;
skip 'too old', 8 if $] < 5.008;
# Math::BigFloat values with enabled bignum
is($bigcjson->encode(Math::BigFloat->new('18446744073709551616.5'), JSON_TYPE_FLOAT), '18446744073709551616.5'); # 2^64
is($bigcjson->encode(Math::BigFloat->new('18446744073709551617.5'), JSON_TYPE_FLOAT), '18446744073709551617.5'); # 2^64+1
is($bigcjson->encode(Math::BigFloat->new('18446744073709551618.5'), JSON_TYPE_FLOAT), '18446744073709551618.5'); # 2^64+2
is($bigcjson->encode(Math::BigFloat->new('-9223372036854775809.5'), JSON_TYPE_FLOAT), '-9223372036854775809.5'); # -2^63-1
is($bigcjson->encode(Math::BigFloat->new('-9223372036854775810.5'), JSON_TYPE_FLOAT), '-9223372036854775810.5'); # -2^63-2
is($bigcjson->encode(Math::BigFloat->new('NaN'), JSON_TYPE_FLOAT), '0.0');
is($bigcjson->encode(Math::BigFloat->new('+inf'), JSON_TYPE_FLOAT), $fltinf);
is($bigcjson->encode(Math::BigFloat->new('-inf'), JSON_TYPE_FLOAT), "-$fltinf");
}
SKIP: {
skip 'requires Math::BigInt', 1 unless eval { require Math::BigInt };
my $stringified_int = '-9223372036854775810';
do { my $temp = $stringified_int + 10 };
is($bigcjson->encode($stringified_int, JSON_TYPE_INT), '-9223372036854775810');
}
t/test_parsing/n_number_-NaN.json view on Meta::CPAN
[-NaN]
t/test_parsing/n_number_NaN.json view on Meta::CPAN
[NaN]
xt/pod-spelling.t view on Meta::CPAN
Iceweasel
JSON
JSON's
KOI
Lehmann
MLEHMANN
Mojo
MongoDB
MovableType
NOK
NaN's
OO
QNAN
Pali
Reini
SNAN
STDIN
STDOUT
SixApart
Storable
TCP
( run in 0.458 second using v1.01-cache-2.11-cpan-4d50c553e7e )