658daa6534
based on the existing Number.parseInt. Bug: v8:6791 Change-Id: I9169a4695807a3e435e343d239431ae7f6ccf2a1 Reviewed-on: https://chromium-review.googlesource.com/685990 Reviewed-by: Yang Guo <yangguo@chromium.org> Commit-Queue: Jakob Kummerow <jkummerow@chromium.org> Cr-Commit-Position: refs/heads/master@{#48241}
206 lines
5.8 KiB
JavaScript
206 lines
5.8 KiB
JavaScript
// Copyright 2017 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
// Flags: --allow-natives-syntax --harmony-bigint --no-opt
|
|
|
|
'use strict'
|
|
|
|
const zero = BigInt(0);
|
|
const another_zero = BigInt(0);
|
|
const one = BigInt(1);
|
|
const another_one = BigInt(1);
|
|
const two = BigInt(2);
|
|
const three = BigInt(3);
|
|
const six = BigInt(6);
|
|
|
|
// BigInt
|
|
{
|
|
assertSame(BigInt, BigInt.prototype.constructor)
|
|
}
|
|
|
|
// typeof
|
|
{
|
|
assertEquals(typeof zero, "bigint");
|
|
assertEquals(typeof one, "bigint");
|
|
}
|
|
{
|
|
// TODO(neis): Enable once --no-opt can be removed.
|
|
//
|
|
// function Typeof(x) { return typeof x }
|
|
// assertEquals(Typeof(zero), "bigint");
|
|
// assertEquals(Typeof(zero), "bigint");
|
|
// %OptimizeFunctionOnNextCall(Typeof);
|
|
// assertEquals(Typeof(zero), "bigint");
|
|
}
|
|
|
|
// ToString
|
|
{
|
|
assertEquals(String(zero), "0");
|
|
assertEquals(String(one), "1");
|
|
}
|
|
|
|
// .toString(radix)
|
|
{
|
|
// assertEquals(expected, BigInt(input).toString(n)) is generated by:
|
|
// input = $(python -c "print(int('expected', n))")
|
|
assertEquals("hello", BigInt(18306744).toString(32));
|
|
assertEquals("-hello", BigInt(-18306744).toString(32));
|
|
assertEquals("abcde", BigInt(0xabcde).toString(16));
|
|
assertEquals("-abcde", BigInt(-0xabcde).toString(16));
|
|
assertEquals("1234567", BigInt(342391).toString(8));
|
|
assertEquals("-1234567", BigInt(-342391).toString(8));
|
|
assertEquals("1230123", BigInt(6939).toString(4));
|
|
assertEquals("-1230123", BigInt(-6939).toString(4));
|
|
assertEquals("1011001110001", BigInt(5745).toString(2));
|
|
assertEquals("-1011001110001", BigInt(-5745).toString(2));
|
|
}
|
|
|
|
// .parseInt
|
|
{
|
|
assertEquals("hellobigint", BigInt.parseInt("hellobigint", 32).toString(32));
|
|
assertEquals("abc", BigInt.parseInt("101010111100", 2).toString(16));
|
|
// Detect "0x" prefix.
|
|
assertEquals("f00dcafe", BigInt.parseInt("0xf00dcafe").toString(16));
|
|
// Default base is 10, trailing junk is skipped.
|
|
assertEquals("abc", BigInt.parseInt("2748junk").toString(16));
|
|
// Objects are converted to string.
|
|
let obj = {toString: () => "0x12345"};
|
|
assertEquals("12345", BigInt.parseInt(obj).toString(16));
|
|
// Empty and invalid strings throw.
|
|
assertThrows("BigInt.parseInt('')", SyntaxError);
|
|
assertThrows("BigInt.parseInt('nope', 2)", SyntaxError);
|
|
}
|
|
|
|
// .valueOf
|
|
{
|
|
assertEquals(Object(zero).valueOf(), another_zero);
|
|
assertThrows(() => { return BigInt.prototype.valueOf.call("string"); },
|
|
TypeError);
|
|
// TODO(jkummerow): Add tests for (new BigInt(...)).valueOf() when we
|
|
// can construct BigInt wrappers.
|
|
}
|
|
|
|
// ToBoolean
|
|
{
|
|
assertTrue(!zero);
|
|
assertFalse(!!zero);
|
|
assertTrue(!!!zero);
|
|
|
|
assertFalse(!one);
|
|
assertTrue(!!one);
|
|
assertFalse(!!!one);
|
|
}
|
|
|
|
// Strict equality
|
|
{
|
|
assertTrue(zero === zero);
|
|
assertFalse(zero !== zero);
|
|
|
|
assertTrue(zero === another_zero);
|
|
assertFalse(zero !== another_zero);
|
|
|
|
assertFalse(zero === one);
|
|
assertTrue(zero !== one);
|
|
assertTrue(one !== zero);
|
|
assertFalse(one === zero);
|
|
|
|
assertFalse(zero === 0);
|
|
assertTrue(zero !== 0);
|
|
assertFalse(0 === zero);
|
|
assertTrue(0 !== zero);
|
|
}
|
|
|
|
// SameValue
|
|
{
|
|
const obj = Object.defineProperty({}, 'foo',
|
|
{value: zero, writable: false, configurable: false});
|
|
|
|
assertTrue(Reflect.defineProperty(obj, 'foo', {value: zero}));
|
|
assertTrue(Reflect.defineProperty(obj, 'foo', {value: another_zero}));
|
|
assertFalse(Reflect.defineProperty(obj, 'foo', {value: one}));
|
|
}
|
|
|
|
// SameValueZero
|
|
{
|
|
assertTrue([zero].includes(zero));
|
|
assertTrue([zero].includes(another_zero));
|
|
|
|
assertFalse([zero].includes(+0));
|
|
assertFalse([zero].includes(-0));
|
|
|
|
assertFalse([+0].includes(zero));
|
|
assertFalse([-0].includes(zero));
|
|
|
|
assertTrue([one].includes(one));
|
|
assertTrue([one].includes(another_one));
|
|
|
|
assertFalse([one].includes(1));
|
|
assertFalse([1].includes(one));
|
|
}{
|
|
assertTrue(new Set([zero]).has(zero));
|
|
assertTrue(new Set([zero]).has(another_zero));
|
|
|
|
assertFalse(new Set([zero]).has(+0));
|
|
assertFalse(new Set([zero]).has(-0));
|
|
|
|
assertFalse(new Set([+0]).has(zero));
|
|
assertFalse(new Set([-0]).has(zero));
|
|
|
|
assertTrue(new Set([one]).has(one));
|
|
assertTrue(new Set([one]).has(another_one));
|
|
}{
|
|
assertTrue(new Map([[zero, 42]]).has(zero));
|
|
assertTrue(new Map([[zero, 42]]).has(another_zero));
|
|
|
|
assertFalse(new Map([[zero, 42]]).has(+0));
|
|
assertFalse(new Map([[zero, 42]]).has(-0));
|
|
|
|
assertFalse(new Map([[+0, 42]]).has(zero));
|
|
assertFalse(new Map([[-0, 42]]).has(zero));
|
|
|
|
assertTrue(new Map([[one, 42]]).has(one));
|
|
assertTrue(new Map([[one, 42]]).has(another_one));
|
|
}
|
|
|
|
// Binary ops.
|
|
{
|
|
assertTrue(one + two === three);
|
|
assertEquals("hello1", "hello" + one);
|
|
assertEquals("2hello", two + "hello");
|
|
assertThrows("one + 2", TypeError);
|
|
assertThrows("2 + one", TypeError);
|
|
assertThrows("one + 0.5", TypeError);
|
|
assertThrows("0.5 + one", TypeError);
|
|
assertThrows("one + null", TypeError);
|
|
assertThrows("null + one", TypeError);
|
|
|
|
assertTrue(three - two === one);
|
|
assertThrows("two - 1", TypeError);
|
|
assertThrows("2 - one", TypeError);
|
|
assertThrows("two - 0.5", TypeError);
|
|
assertThrows("2.5 - one", TypeError);
|
|
|
|
assertTrue(two * three === six);
|
|
assertThrows("two * 1", TypeError);
|
|
assertThrows("1 * two", TypeError);
|
|
assertThrows("two * 1.5", TypeError);
|
|
assertThrows("1.5 * two", TypeError);
|
|
|
|
assertTrue(six / three === two);
|
|
assertThrows("six / 3", TypeError);
|
|
assertThrows("3 / three", TypeError);
|
|
assertThrows("six / 0.5", TypeError);
|
|
assertThrows("0.5 / six", TypeError);
|
|
assertThrows("zero / zero", RangeError);
|
|
assertThrows("zero / 0", TypeError);
|
|
|
|
assertTrue(three % two === one);
|
|
assertThrows("three % 2", TypeError);
|
|
assertThrows("3 % two", TypeError);
|
|
assertThrows("three % 2.5", TypeError);
|
|
assertThrows("3.5 % two", TypeError);
|
|
assertThrows("three % zero", RangeError);
|
|
assertThrows("three % 0", TypeError);
|
|
}
|