mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 01:59:38 +00:00
bc937b3b6b
This is the 2nd attempt to land the CL
abed3c2a70
Original review: https://codereview.chromium.org/2982823002
No extra changes were made. Large literals in the Dart core library
which caused failures during the previous attempt to land this CL have
been fixed separately.
Description of the CL:
In --limit-ints-to-64-bits mode:
* Integer constructors return Integer::null if integer is out of range.
* Error is reported for integer literals which are out of range.
* Dart API is revised to return errors if integers are out of range.
Bigint::IsDisabled() method is introduced to be able to enable/disable
Bigints independently of --limit-ints-to-64-bits mode in future.
Deprecated constructor Integer::NewFromUint64 is replaced with
Integer::New in certain cases.
R=regis@google.com
Issue: https://github.com/dart-lang/sdk/issues/30103
Review-Url: https://codereview.chromium.org/2980223002 .
676 lines
22 KiB
C++
676 lines
22 KiB
C++
// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#include "platform/assert.h"
|
|
#include "vm/object.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/unit_test.h"
|
|
|
|
namespace dart {
|
|
|
|
TEST_CASE(BigintSmi) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
{
|
|
const Smi& smi = Smi::Handle(Smi::New(5));
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
|
|
EXPECT_EQ(5, bigint.AsInt64Value());
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
Smi& smi_back = Smi::Handle();
|
|
smi_back ^= bigint.AsValidInteger();
|
|
EXPECT_EQ(5, smi_back.Value());
|
|
}
|
|
|
|
{
|
|
const Smi& smi = Smi::Handle(Smi::New(Smi::kMaxValue));
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
|
|
EXPECT(Smi::kMaxValue == bigint.AsInt64Value());
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
Smi& smi_back = Smi::Handle();
|
|
smi_back ^= bigint.AsValidInteger();
|
|
EXPECT(Smi::kMaxValue == smi_back.Value());
|
|
}
|
|
|
|
{
|
|
const Smi& smi = Smi::Handle(Smi::New(Smi::kMinValue));
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
|
|
EXPECT(bigint.IsNegative());
|
|
EXPECT(Smi::kMinValue == bigint.AsInt64Value());
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
Smi& smi_back = Smi::Handle();
|
|
smi_back ^= bigint.AsValidInteger();
|
|
EXPECT(Smi::kMinValue == smi_back.Value());
|
|
}
|
|
|
|
{
|
|
ASSERT(0xFFFFFFF < Smi::kMaxValue);
|
|
const Smi& smi = Smi::Handle(Smi::New(0xFFFFFFF));
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
|
|
EXPECT_EQ(0xFFFFFFF, bigint.AsInt64Value());
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
Smi& smi_back = Smi::Handle();
|
|
smi_back ^= bigint.AsValidInteger();
|
|
EXPECT_EQ(0xFFFFFFF, smi_back.Value());
|
|
}
|
|
|
|
{
|
|
ASSERT(0x10000000 < Smi::kMaxValue);
|
|
const Smi& smi = Smi::Handle(Smi::New(0x10000000));
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(smi.Value()));
|
|
EXPECT_EQ(0x10000000, bigint.AsInt64Value());
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
Smi& smi_back = Smi::Handle();
|
|
smi_back ^= bigint.AsValidInteger();
|
|
EXPECT(0x10000000 == smi_back.Value());
|
|
}
|
|
}
|
|
|
|
TEST_CASE(BigintInt64) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
const int64_t kValue = 100000000;
|
|
const int64_t kValue64 = kValue * kValue;
|
|
Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(kValue));
|
|
EXPECT_EQ(kValue, bigint.AsInt64Value());
|
|
bigint = Bigint::NewFromInt64(kValue64);
|
|
EXPECT_EQ(kValue64, bigint.AsInt64Value());
|
|
bigint = Bigint::NewFromInt64(-kValue64);
|
|
EXPECT_EQ(-kValue64, bigint.AsInt64Value());
|
|
bigint = Bigint::NewFromInt64(kMinInt64);
|
|
EXPECT(bigint.FitsIntoInt64());
|
|
EXPECT_EQ(kMinInt64, bigint.AsInt64Value());
|
|
}
|
|
|
|
TEST_CASE(BigintUint64) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
const Bigint& one = Bigint::Handle(Bigint::NewFromUint64(1));
|
|
EXPECT(one.FitsIntoInt64());
|
|
EXPECT(one.FitsIntoUint64());
|
|
|
|
const Bigint& big = Bigint::Handle(Bigint::NewFromUint64(kMaxUint64));
|
|
EXPECT(!big.FitsIntoInt64());
|
|
EXPECT(big.FitsIntoUint64());
|
|
|
|
uint64_t back = big.AsUint64Value();
|
|
EXPECT_EQ(kMaxUint64, back);
|
|
}
|
|
|
|
TEST_CASE(BigintDouble) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
Bigint& bigint = Bigint::Handle(Bigint::NewFromInt64(5));
|
|
EXPECT_EQ(5.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromInt64(0);
|
|
EXPECT_EQ(0.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromInt64(-12345678);
|
|
EXPECT_EQ(-1.2345678e+7, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("1");
|
|
EXPECT_EQ(1.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("123456");
|
|
EXPECT_EQ(123456.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("123456789");
|
|
EXPECT_EQ(123456789.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("12345678901234567");
|
|
EXPECT_EQ(12345678901234568.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("98765432109876");
|
|
EXPECT_EQ(9.8765432109876e+13, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x17777777777778");
|
|
EXPECT_EQ(6605279453476728.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x37777777777778");
|
|
EXPECT_EQ(15612478708217720.0, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x177777777777781234567");
|
|
EXPECT_EQ(1.7730912021014563e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x177777777777788000000");
|
|
EXPECT_EQ(1.7730912021014563e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x177777777777788000001");
|
|
EXPECT_EQ(1.7730912021014565e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x177777777777798000000");
|
|
EXPECT_EQ(1.7730912021014568e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x177777777777798000001");
|
|
EXPECT_EQ(1.7730912021014568e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x377777777777790000000");
|
|
EXPECT_EQ(4.1909428413307146e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x377777777777790000001");
|
|
EXPECT_EQ(4.190942841330715e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x377777777777730000000");
|
|
EXPECT_EQ(4.1909428413307135e+24, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("0x377777777777730000001");
|
|
EXPECT_EQ(4.1909428413307135e+24, bigint.AsDoubleValue());
|
|
|
|
// Reduced precision.
|
|
bigint = Bigint::NewFromCString("9876543210987654321098765432109876543210");
|
|
EXPECT_EQ(9.8765432109876546e+39, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString(
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890"
|
|
"12345678901234567890123456789012345678901234567890");
|
|
double zero = 0.0;
|
|
EXPECT_EQ(1.0 / zero, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString(
|
|
"17976931348623157081452742373170435679807056752584"
|
|
"49965989174768031572607800285387605895586327668781"
|
|
"71540458953514382464234321326889464182768467546703"
|
|
"53751698604991057655128207624549009038932894407586"
|
|
"85084551339423045832369032229481658085593321233482"
|
|
"74797826204144723168738177180919299881250404026184"
|
|
"124858368");
|
|
EXPECT_EQ(1.7976931348623157e308, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString(
|
|
"17976931348623159077293051907890247336179769789423"
|
|
"06572734300811577326758055009631327084773224075360"
|
|
"21120113879871393357658789768814416622492847430639"
|
|
"47412437776789342486548527630221960124609411945308"
|
|
"29520850057688381506823424628814739131105408272371"
|
|
"63350510684586298239947245938479716304835356329624"
|
|
"224137216");
|
|
EXPECT_EQ(1.0 / zero, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString(
|
|
"17976931348623158079372897140530341507993413271003"
|
|
"78269361737789804449682927647509466490179775872070"
|
|
"96330286416692887910946555547851940402630657488671"
|
|
"50582068190890200070838367627385484581771153176447"
|
|
"57302700698555713669596228429148198608349364752927"
|
|
"19074168444365510704342711559699508093042880177904"
|
|
"174497792");
|
|
EXPECT_EQ(1.0 / zero, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString(
|
|
"17976931348623158079372897140530341507993413271003"
|
|
"78269361737789804449682927647509466490179775872070"
|
|
"96330286416692887910946555547851940402630657488671"
|
|
"50582068190890200070838367627385484581771153176447"
|
|
"57302700698555713669596228429148198608349364752927"
|
|
"19074168444365510704342711559699508093042880177904"
|
|
"174497791");
|
|
EXPECT_EQ(1.7976931348623157e308, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("100000000000000000000000");
|
|
EXPECT_EQ(1e+23, bigint.AsDoubleValue());
|
|
|
|
bigint = Bigint::NewFromCString("100000000000000000000001");
|
|
EXPECT_EQ(1.0000000000000001e+23, bigint.AsDoubleValue());
|
|
|
|
// Same but shifted 64 bits to the left.
|
|
bigint =
|
|
Bigint::NewFromCString("1844674407370955161600000000000000000000000");
|
|
EXPECT_EQ(1.844674407370955e+42, bigint.AsDoubleValue());
|
|
|
|
bigint =
|
|
Bigint::NewFromCString("1844674407370955161600000000000000000000001");
|
|
EXPECT_EQ(1.8446744073709553e+42, bigint.AsDoubleValue());
|
|
}
|
|
|
|
TEST_CASE(BigintHexStrings) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
Zone* zone = Thread::Current()->zone();
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x0"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(0, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x1"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(1, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(0x123, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0x123", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0xaBcEf"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0xABCEF", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x123456789";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(in, str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0xFFFFFFF";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(in, str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x10000000";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(in, str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(in, str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(-0x123, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0x123", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0xaBcEf"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0xABCEF", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "-0x123456789";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(in, str);
|
|
}
|
|
|
|
{
|
|
const char* in = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(in, str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x00000123"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(0x123, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("0x000000123"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0x123", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("0x0000aBcEf"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0xABCEF", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x00000000000000000000000000000000000000000000123456789";
|
|
const char* out = "0x123456789";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(out, str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x00000123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const char* out = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(out, str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("-0x00000123"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(-0x123, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("-0x00000123"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0x123", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("-0x000aBcEf"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0xABCEF", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "-0x00000000000000000000000000000000000000000000123456789";
|
|
const char* out = "-0x123456789";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(out, str);
|
|
}
|
|
|
|
{
|
|
const char* in = "-0x0000123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const char* out = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(out, str);
|
|
}
|
|
{
|
|
const char* test = "12345678901234567890";
|
|
const char* out = "0xAB54A98CEB1F0AD2";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(test));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(out, str);
|
|
}
|
|
{
|
|
const char* test = "-12345678901234567890";
|
|
const char* out = "-0xAB54A98CEB1F0AD2";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(test));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ(out, str);
|
|
}
|
|
}
|
|
|
|
TEST_CASE(BigintDecStrings) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
Zone* zone = Thread::Current()->zone();
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x0"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("0", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x123"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("291", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0xaBcEf"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("703727", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x123456789";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("4886718345", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0xFFFFFFF";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("268435455", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x10000000";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("268435456", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("7141946863373290020600059860922167424469804758405880798960",
|
|
str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(-291, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0x123"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("-291", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0xaBcEf"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("-703727", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "-0x123456789";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("-4886718345", str);
|
|
}
|
|
|
|
{
|
|
const char* in = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString(in));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("-7141946863373290020600059860922167424469804758405880798960",
|
|
str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0x00000123"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(0x123, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("0x000000123"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("291", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(
|
|
Bigint::NewFromCString("100000000000000000000000000000000"));
|
|
const char* str = bigint.ToDecCString(zone);
|
|
EXPECT_STREQ("100000000000000000000000000000000", str);
|
|
}
|
|
}
|
|
|
|
static void TestBigintCompare(const char* a, const char* b, int compare) {
|
|
const Bigint& bigint_a = Bigint::Handle(Bigint::NewFromCString(a));
|
|
const Bigint& bigint_b = Bigint::Handle(Bigint::NewFromCString(b));
|
|
const Integer& int_a = Integer::Handle(bigint_a.AsValidInteger());
|
|
const Integer& int_b = Integer::Handle(bigint_b.AsValidInteger());
|
|
int computed_compare = int_a.CompareWith(int_b);
|
|
int inverted_compare = int_b.CompareWith(int_a);
|
|
if (compare == 0) {
|
|
EXPECT(computed_compare == 0);
|
|
EXPECT(inverted_compare == 0);
|
|
} else if (compare < 0) {
|
|
ASSERT(computed_compare < 0);
|
|
EXPECT(computed_compare < 0);
|
|
EXPECT(inverted_compare > 0);
|
|
} else {
|
|
ASSERT(compare > 0);
|
|
EXPECT(computed_compare > 0);
|
|
EXPECT(inverted_compare < 0);
|
|
}
|
|
}
|
|
|
|
TEST_CASE(BigintCompare) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
TestBigintCompare("0x0", "0x0", 0);
|
|
TestBigintCompare("0x1", "0x1", 0);
|
|
TestBigintCompare("-0x1", "-0x1", 0);
|
|
TestBigintCompare("0x1234567", "0x1234567", 0);
|
|
TestBigintCompare("-0x1234567", "-0x1234567", 0);
|
|
TestBigintCompare("0x12345678", "0x12345678", 0);
|
|
TestBigintCompare("-0x12345678", "-0x12345678", 0);
|
|
TestBigintCompare("0x123456789ABCDEF0", "0x123456789ABCDEF0", 0);
|
|
TestBigintCompare("-0x123456789ABCDEF0", "-0x123456789ABCDEF0", 0);
|
|
TestBigintCompare("0x123456789ABCDEF01", "0x123456789ABCDEF01", 0);
|
|
TestBigintCompare("-0x123456789ABCDEF01", "-0x123456789ABCDEF01", 0);
|
|
TestBigintCompare("0x1", "0x0", 1);
|
|
TestBigintCompare("-0x1", "-0x2", 1);
|
|
TestBigintCompare("0x1234567", "0x1234566", 1);
|
|
TestBigintCompare("-0x1234567", "-0x1234568", 1);
|
|
TestBigintCompare("0x12345678", "0x12345677", 1);
|
|
TestBigintCompare("-0x12345678", "-0x12345679", 1);
|
|
TestBigintCompare("0x123456789ABCDEF1", "0x123456789ABCDEF0", 1);
|
|
TestBigintCompare("-0x123456789ABCDEF0", "-0x123456789ABCDEF1", 1);
|
|
TestBigintCompare("0x123456789ABCDEF02", "0x123456789ABCDEF01", 1);
|
|
TestBigintCompare("-0x123456789ABCDEF00", "-0x123456789ABCDEF01", 1);
|
|
TestBigintCompare("0x10000000", "0xFFFFFFF", 1);
|
|
TestBigintCompare("-0x10000000", "-0xFFFFFFF", -1);
|
|
TestBigintCompare("0x100000000", "0xFFFFFFFF", 1);
|
|
TestBigintCompare("-0x100000000", "-0xFFFFFFFF", -1);
|
|
TestBigintCompare("0x10000000000000000", "0xFFFFFFFFFFFFFFFF", 1);
|
|
TestBigintCompare("-0x10000000000000000", "-0xFFFFFFFFFFFFFFFF", -1);
|
|
TestBigintCompare("0x10000000000000000", "0x0", 1);
|
|
TestBigintCompare("-0x10000000000000000", "0x0", -1);
|
|
TestBigintCompare("-0x1234567", "0x1234566", -1);
|
|
TestBigintCompare("-0x1234567", "0x1234568", -1);
|
|
TestBigintCompare("-0x12345678", "0x12345677", -1);
|
|
TestBigintCompare("-0x12345678", "0x12345670", -1);
|
|
TestBigintCompare("-0x123456789ABCDEF1", "0x123456789ABCDEF0", -1);
|
|
TestBigintCompare("-0x123456789ABCDEF0", "0x123456789ABCDEF1", -1);
|
|
TestBigintCompare("-0x123456789ABCDEF02", "0x123456789ABCDEF01", -1);
|
|
TestBigintCompare("-0x123456789ABCDEF00", "0x123456789ABCDEF01", -1);
|
|
TestBigintCompare("-0x10000000", "0xFFFFFFF", -1);
|
|
TestBigintCompare("-0x10000000", "0xFFFFFFF", -1);
|
|
TestBigintCompare("-0x100000000", "0xFFFFFFFF", -1);
|
|
TestBigintCompare("-0x100000000", "0xFFFFFFFF", -1);
|
|
TestBigintCompare("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", -1);
|
|
TestBigintCompare("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", -1);
|
|
TestBigintCompare("-0x10000000000000000", "0x0", -1);
|
|
TestBigintCompare("-0x10000000000000000", "0x0", -1);
|
|
}
|
|
|
|
TEST_CASE(BigintDecimalStrings) {
|
|
if (Bigint::IsDisabled()) {
|
|
return;
|
|
}
|
|
|
|
Zone* zone = Thread::Current()->zone();
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("0"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(0, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("1"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(1, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("703710"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0xABCDE", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("11259375"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0xABCDEF", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("1311768467463790320"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("0x123456789ABCDEF0", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-0"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(0, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-1"));
|
|
EXPECT(bigint.FitsIntoSmi());
|
|
EXPECT_EQ(-1, bigint.AsInt64Value());
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-703710"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0xABCDE", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint = Bigint::Handle(Bigint::NewFromCString("-11259375"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0xABCDEF", str);
|
|
}
|
|
|
|
{
|
|
const Bigint& bigint =
|
|
Bigint::Handle(Bigint::NewFromCString("-1311768467463790320"));
|
|
const char* str = bigint.ToHexCString(zone);
|
|
EXPECT_STREQ("-0x123456789ABCDEF0", str);
|
|
}
|
|
}
|
|
|
|
} // namespace dart
|