LCOV - code coverage report
Current view: top level - test/cctest - test-conversions.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 239 239 100.0 %
Date: 2019-04-17 Functions: 22 22 100.0 %

          Line data    Source code
       1             : // Copyright 2011 the V8 project authors. All rights reserved.
       2             : // Redistribution and use in source and binary forms, with or without
       3             : // modification, are permitted provided that the following conditions are
       4             : // met:
       5             : //
       6             : //     * Redistributions of source code must retain the above copyright
       7             : //       notice, this list of conditions and the following disclaimer.
       8             : //     * Redistributions in binary form must reproduce the above
       9             : //       copyright notice, this list of conditions and the following
      10             : //       disclaimer in the documentation and/or other materials provided
      11             : //       with the distribution.
      12             : //     * Neither the name of Google Inc. nor the names of its
      13             : //       contributors may be used to endorse or promote products derived
      14             : //       from this software without specific prior written permission.
      15             : //
      16             : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      17             : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      18             : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      19             : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      20             : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      21             : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      22             : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      23             : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      24             : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      25             : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      26             : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      27             : 
      28             : #include <stdlib.h>
      29             : 
      30             : #include "src/base/platform/platform.h"
      31             : #include "src/conversions.h"
      32             : #include "src/heap/factory-inl.h"
      33             : #include "src/isolate.h"
      34             : #include "src/objects.h"
      35             : #include "src/objects/heap-number-inl.h"
      36             : #include "src/objects/smi.h"
      37             : #include "src/v8.h"
      38             : #include "test/cctest/cctest.h"
      39             : 
      40             : namespace v8 {
      41             : namespace internal {
      42             : 
      43       26644 : TEST(Hex) {
      44           5 :   CHECK_EQ(0.0, StringToDouble("0x0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      45           5 :   CHECK_EQ(0.0, StringToDouble("0X0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      46           5 :   CHECK_EQ(1.0, StringToDouble("0x1", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      47           5 :   CHECK_EQ(16.0, StringToDouble("0x10", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      48           5 :   CHECK_EQ(255.0, StringToDouble("0xFF", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      49           5 :   CHECK_EQ(175.0, StringToDouble("0xAF", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      50             : 
      51           5 :   CHECK_EQ(0.0, StringToDouble("0x0", ALLOW_HEX));
      52           5 :   CHECK_EQ(0.0, StringToDouble("0X0", ALLOW_HEX));
      53           5 :   CHECK_EQ(1.0, StringToDouble("0x1", ALLOW_HEX));
      54           5 :   CHECK_EQ(16.0, StringToDouble("0x10", ALLOW_HEX));
      55           5 :   CHECK_EQ(255.0, StringToDouble("0xFF", ALLOW_HEX));
      56           5 :   CHECK_EQ(175.0, StringToDouble("0xAF", ALLOW_HEX));
      57           5 : }
      58             : 
      59             : 
      60       26644 : TEST(Octal) {
      61           5 :   CHECK_EQ(0.0, StringToDouble("0o0", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
      62           5 :   CHECK_EQ(0.0, StringToDouble("0O0", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
      63           5 :   CHECK_EQ(1.0, StringToDouble("0o1", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
      64           5 :   CHECK_EQ(7.0, StringToDouble("0o7", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
      65           5 :   CHECK_EQ(8.0, StringToDouble("0o10", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
      66           5 :   CHECK_EQ(63.0, StringToDouble("0o77", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
      67             : 
      68           5 :   CHECK_EQ(0.0, StringToDouble("0o0", ALLOW_OCTAL));
      69           5 :   CHECK_EQ(0.0, StringToDouble("0O0", ALLOW_OCTAL));
      70           5 :   CHECK_EQ(1.0, StringToDouble("0o1", ALLOW_OCTAL));
      71           5 :   CHECK_EQ(7.0, StringToDouble("0o7", ALLOW_OCTAL));
      72           5 :   CHECK_EQ(8.0, StringToDouble("0o10", ALLOW_OCTAL));
      73           5 :   CHECK_EQ(63.0, StringToDouble("0o77", ALLOW_OCTAL));
      74           5 : }
      75             : 
      76             : 
      77       26644 : TEST(ImplicitOctal) {
      78           5 :   CHECK_EQ(0.0, StringToDouble("0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      79           5 :   CHECK_EQ(0.0, StringToDouble("00", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      80           5 :   CHECK_EQ(1.0, StringToDouble("01", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      81           5 :   CHECK_EQ(7.0, StringToDouble("07", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      82           5 :   CHECK_EQ(8.0, StringToDouble("010", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      83           5 :   CHECK_EQ(63.0, StringToDouble("077", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
      84             : 
      85           5 :   CHECK_EQ(0.0, StringToDouble("0", ALLOW_HEX));
      86           5 :   CHECK_EQ(0.0, StringToDouble("00", ALLOW_HEX));
      87           5 :   CHECK_EQ(1.0, StringToDouble("01", ALLOW_HEX));
      88           5 :   CHECK_EQ(7.0, StringToDouble("07", ALLOW_HEX));
      89           5 :   CHECK_EQ(10.0, StringToDouble("010", ALLOW_HEX));
      90           5 :   CHECK_EQ(77.0, StringToDouble("077", ALLOW_HEX));
      91             : 
      92             :   const double x = 010000000000;  // Power of 2, no rounding errors.
      93           5 :   CHECK_EQ(x * x * x * x * x, StringToDouble("01"
      94             :                                              "0000000000"
      95             :                                              "0000000000"
      96             :                                              "0000000000"
      97             :                                              "0000000000"
      98             :                                              "0000000000",
      99             :                                              ALLOW_IMPLICIT_OCTAL));
     100           5 : }
     101             : 
     102             : 
     103       26644 : TEST(Binary) {
     104           5 :   CHECK_EQ(0.0, StringToDouble("0b0", ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
     105           5 :   CHECK_EQ(0.0, StringToDouble("0B0", ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
     106           5 :   CHECK_EQ(1.0, StringToDouble("0b1", ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
     107           5 :   CHECK_EQ(2.0, StringToDouble("0b10", ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
     108           5 :   CHECK_EQ(3.0, StringToDouble("0b11", ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
     109             : 
     110           5 :   CHECK_EQ(0.0, StringToDouble("0b0", ALLOW_BINARY));
     111           5 :   CHECK_EQ(0.0, StringToDouble("0B0", ALLOW_BINARY));
     112           5 :   CHECK_EQ(1.0, StringToDouble("0b1", ALLOW_BINARY));
     113           5 :   CHECK_EQ(2.0, StringToDouble("0b10", ALLOW_BINARY));
     114           5 :   CHECK_EQ(3.0, StringToDouble("0b11", ALLOW_BINARY));
     115           5 : }
     116             : 
     117             : 
     118       26644 : TEST(MalformedOctal) {
     119           5 :   CHECK_EQ(8.0, StringToDouble("08", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     120           5 :   CHECK_EQ(81.0, StringToDouble("081", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     121           5 :   CHECK_EQ(78.0, StringToDouble("078", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     122             : 
     123           5 :   CHECK(std::isnan(StringToDouble("07.7", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
     124           5 :   CHECK(std::isnan(StringToDouble("07.8", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
     125           5 :   CHECK(std::isnan(StringToDouble("07e8", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
     126           5 :   CHECK(std::isnan(StringToDouble("07e7", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
     127             : 
     128           5 :   CHECK_EQ(8.7, StringToDouble("08.7", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     129           5 :   CHECK_EQ(8e7, StringToDouble("08e7", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     130             : 
     131           5 :   CHECK_EQ(0.001, StringToDouble("0.001", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     132           5 :   CHECK_EQ(0.713, StringToDouble("0.713", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     133             : 
     134           5 :   CHECK_EQ(8.0, StringToDouble("08", ALLOW_HEX));
     135           5 :   CHECK_EQ(81.0, StringToDouble("081", ALLOW_HEX));
     136           5 :   CHECK_EQ(78.0, StringToDouble("078", ALLOW_HEX));
     137             : 
     138           5 :   CHECK_EQ(7.7, StringToDouble("07.7", ALLOW_HEX));
     139           5 :   CHECK_EQ(7.8, StringToDouble("07.8", ALLOW_HEX));
     140           5 :   CHECK_EQ(7e8, StringToDouble("07e8", ALLOW_HEX));
     141           5 :   CHECK_EQ(7e7, StringToDouble("07e7", ALLOW_HEX));
     142             : 
     143           5 :   CHECK_EQ(8.7, StringToDouble("08.7", ALLOW_HEX));
     144           5 :   CHECK_EQ(8e7, StringToDouble("08e7", ALLOW_HEX));
     145             : 
     146           5 :   CHECK_EQ(0.001, StringToDouble("0.001", ALLOW_HEX));
     147           5 :   CHECK_EQ(0.713, StringToDouble("0.713", ALLOW_HEX));
     148           5 : }
     149             : 
     150             : 
     151       26644 : TEST(TrailingJunk) {
     152           5 :   CHECK_EQ(8.0, StringToDouble("8q", ALLOW_TRAILING_JUNK));
     153           5 :   CHECK_EQ(63.0, StringToDouble("077qqq",
     154             :                                 ALLOW_IMPLICIT_OCTAL | ALLOW_TRAILING_JUNK));
     155           5 :   CHECK_EQ(10.0,
     156             :            StringToDouble("10e", ALLOW_IMPLICIT_OCTAL | ALLOW_TRAILING_JUNK));
     157           5 :   CHECK_EQ(10.0,
     158             :            StringToDouble("10e-", ALLOW_IMPLICIT_OCTAL | ALLOW_TRAILING_JUNK));
     159           5 : }
     160             : 
     161             : 
     162       26644 : TEST(NonStrDecimalLiteral) {
     163           5 :   CHECK(std::isnan(
     164             :       StringToDouble(" ", NO_FLAGS, std::numeric_limits<double>::quiet_NaN())));
     165           5 :   CHECK(std::isnan(
     166             :       StringToDouble("", NO_FLAGS, std::numeric_limits<double>::quiet_NaN())));
     167           5 :   CHECK(std::isnan(
     168             :       StringToDouble(" ", NO_FLAGS, std::numeric_limits<double>::quiet_NaN())));
     169           5 :   CHECK_EQ(0.0, StringToDouble("", NO_FLAGS));
     170           5 :   CHECK_EQ(0.0, StringToDouble(" ", NO_FLAGS));
     171           5 : }
     172             : 
     173             : 
     174       26644 : TEST(IntegerStrLiteral) {
     175           5 :   CHECK_EQ(0.0, StringToDouble("0.0", NO_FLAGS));
     176           5 :   CHECK_EQ(0.0, StringToDouble("0", NO_FLAGS));
     177           5 :   CHECK_EQ(0.0, StringToDouble("00", NO_FLAGS));
     178           5 :   CHECK_EQ(0.0, StringToDouble("000", NO_FLAGS));
     179           5 :   CHECK_EQ(1.0, StringToDouble("1", NO_FLAGS));
     180           5 :   CHECK_EQ(-1.0, StringToDouble("-1", NO_FLAGS));
     181           5 :   CHECK_EQ(-1.0, StringToDouble("  -1  ", NO_FLAGS));
     182           5 :   CHECK_EQ(1.0, StringToDouble("  +1  ", NO_FLAGS));
     183           5 :   CHECK(std::isnan(StringToDouble("  -  1  ", NO_FLAGS)));
     184           5 :   CHECK(std::isnan(StringToDouble("  +  1  ", NO_FLAGS)));
     185             : 
     186           5 :   CHECK_EQ(0.0, StringToDouble("0e0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     187           5 :   CHECK_EQ(0.0, StringToDouble("0e1", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     188           5 :   CHECK_EQ(0.0, StringToDouble("0e-1", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     189           5 :   CHECK_EQ(0.0, StringToDouble("0e-100000", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     190           5 :   CHECK_EQ(0.0, StringToDouble("0e+100000", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     191           5 :   CHECK_EQ(0.0, StringToDouble("0.", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
     192           5 : }
     193             : 
     194             : 
     195       26644 : TEST(LongNumberStr) {
     196           5 :   CHECK_EQ(1e10, StringToDouble("1"
     197             :                                 "0000000000",
     198             :                                 NO_FLAGS));
     199           5 :   CHECK_EQ(1e20, StringToDouble("1"
     200             :                                 "0000000000"
     201             :                                 "0000000000",
     202             :                                 NO_FLAGS));
     203             : 
     204           5 :   CHECK_EQ(1e60, StringToDouble("1"
     205             :                                 "0000000000"
     206             :                                 "0000000000"
     207             :                                 "0000000000"
     208             :                                 "0000000000"
     209             :                                 "0000000000"
     210             :                                 "0000000000",
     211             :                                 NO_FLAGS));
     212             : 
     213           5 :   CHECK_EQ(1e-2, StringToDouble("."
     214             :                                 "0"
     215             :                                 "1",
     216             :                                 NO_FLAGS));
     217           5 :   CHECK_EQ(1e-11, StringToDouble("."
     218             :                                  "0000000000"
     219             :                                  "1",
     220             :                                  NO_FLAGS));
     221           5 :   CHECK_EQ(1e-21, StringToDouble("."
     222             :                                  "0000000000"
     223             :                                  "0000000000"
     224             :                                  "1",
     225             :                                  NO_FLAGS));
     226             : 
     227           5 :   CHECK_EQ(1e-61, StringToDouble("."
     228             :                                  "0000000000"
     229             :                                  "0000000000"
     230             :                                  "0000000000"
     231             :                                  "0000000000"
     232             :                                  "0000000000"
     233             :                                  "0000000000"
     234             :                                  "1",
     235             :                                  NO_FLAGS));
     236             : 
     237             :   // x = 24414062505131248.0 and y = 24414062505131252.0 are representable in
     238             :   // double. Check chat z = (x + y) / 2 is rounded to x...
     239           5 :   CHECK_EQ(24414062505131248.0,
     240             :            StringToDouble("24414062505131250.0", NO_FLAGS));
     241             : 
     242             :   // ... and z = (x + y) / 2 + delta is rounded to y.
     243           5 :   CHECK_EQ(24414062505131252.0,
     244             :            StringToDouble("24414062505131250.000000001", NO_FLAGS));
     245           5 : }
     246             : 
     247             : 
     248       26644 : TEST(MaximumSignificantDigits) {
     249             :   char num[] =
     250             :       "4.4501477170144020250819966727949918635852426585926051135169509"
     251             :       "122872622312493126406953054127118942431783801370080830523154578"
     252             :       "251545303238277269592368457430440993619708911874715081505094180"
     253             :       "604803751173783204118519353387964161152051487413083163272520124"
     254             :       "606023105869053620631175265621765214646643181420505164043632222"
     255             :       "668006474326056011713528291579642227455489682133472873831754840"
     256             :       "341397809846934151055619529382191981473003234105366170879223151"
     257             :       "087335413188049110555339027884856781219017754500629806224571029"
     258             :       "581637117459456877330110324211689177656713705497387108207822477"
     259             :       "584250967061891687062782163335299376138075114200886249979505279"
     260             :       "101870966346394401564490729731565935244123171539810221213221201"
     261             :       "847003580761626016356864581135848683152156368691976240370422601"
     262           5 :       "6998291015625000000000000000000000000000000000e-308";
     263             : 
     264           5 :   CHECK_EQ(4.4501477170144017780491e-308, StringToDouble(num, NO_FLAGS));
     265             : 
     266             :   // Changes the result of strtod (at least in glibc implementation).
     267           5 :   num[sizeof(num) - 8] = '1';
     268             : 
     269           5 :   CHECK_EQ(4.4501477170144022721148e-308, StringToDouble(num, NO_FLAGS));
     270           5 : }
     271             : 
     272             : 
     273       26644 : TEST(MinimumExponent) {
     274             :   // Same test but with different point-position.
     275             :   char num[] =
     276             :   "445014771701440202508199667279499186358524265859260511351695091"
     277             :   "228726223124931264069530541271189424317838013700808305231545782"
     278             :   "515453032382772695923684574304409936197089118747150815050941806"
     279             :   "048037511737832041185193533879641611520514874130831632725201246"
     280             :   "060231058690536206311752656217652146466431814205051640436322226"
     281             :   "680064743260560117135282915796422274554896821334728738317548403"
     282             :   "413978098469341510556195293821919814730032341053661708792231510"
     283             :   "873354131880491105553390278848567812190177545006298062245710295"
     284             :   "816371174594568773301103242116891776567137054973871082078224775"
     285             :   "842509670618916870627821633352993761380751142008862499795052791"
     286             :   "018709663463944015644907297315659352441231715398102212132212018"
     287             :   "470035807616260163568645811358486831521563686919762403704226016"
     288           5 :   "998291015625000000000000000000000000000000000e-1108";
     289             : 
     290           5 :   CHECK_EQ(4.4501477170144017780491e-308, StringToDouble(num, NO_FLAGS));
     291             : 
     292             :   // Changes the result of strtod (at least in glibc implementation).
     293           5 :   num[sizeof(num) - 8] = '1';
     294             : 
     295           5 :   CHECK_EQ(4.4501477170144022721148e-308, StringToDouble(num, NO_FLAGS));
     296           5 : }
     297             : 
     298             : 
     299       26644 : TEST(MaximumExponent) {
     300           5 :   char num[] = "0.16e309";
     301             : 
     302           5 :   CHECK_EQ(1.59999999999999997765e+308, StringToDouble(num, NO_FLAGS));
     303           5 : }
     304             : 
     305             : 
     306       26644 : TEST(ExponentNumberStr) {
     307           5 :   CHECK_EQ(1e1, StringToDouble("1e1", NO_FLAGS));
     308           5 :   CHECK_EQ(1e1, StringToDouble("1e+1", NO_FLAGS));
     309           5 :   CHECK_EQ(1e-1, StringToDouble("1e-1", NO_FLAGS));
     310           5 :   CHECK_EQ(1e100, StringToDouble("1e+100", NO_FLAGS));
     311           5 :   CHECK_EQ(1e-100, StringToDouble("1e-100", NO_FLAGS));
     312           5 :   CHECK_EQ(1e-106, StringToDouble(".000001e-100", NO_FLAGS));
     313           5 : }
     314             : 
     315             : 
     316             : class OneBit1: public BitField<uint32_t, 0, 1> {};
     317             : class OneBit2: public BitField<uint32_t, 7, 1> {};
     318             : class EightBit1: public BitField<uint32_t, 0, 8> {};
     319             : class EightBit2: public BitField<uint32_t, 13, 8> {};
     320             : 
     321       26644 : TEST(BitField) {
     322             :   uint32_t x;
     323             : 
     324             :   // One bit bit field can hold values 0 and 1.
     325             :   CHECK(!OneBit1::is_valid(static_cast<uint32_t>(-1)));
     326             :   CHECK(!OneBit2::is_valid(static_cast<uint32_t>(-1)));
     327          25 :   for (unsigned i = 0; i < 2; i++) {
     328          10 :     CHECK(OneBit1::is_valid(i));
     329             :     x = OneBit1::encode(i);
     330          10 :     CHECK_EQ(i, OneBit1::decode(x));
     331             : 
     332          10 :     CHECK(OneBit2::is_valid(i));
     333             :     x = OneBit2::encode(i);
     334          10 :     CHECK_EQ(i, OneBit2::decode(x));
     335             :   }
     336             :   CHECK(!OneBit1::is_valid(2));
     337             :   CHECK(!OneBit2::is_valid(2));
     338             : 
     339             :   // Eight bit bit field can hold values from 0 tp 255.
     340             :   CHECK(!EightBit1::is_valid(static_cast<uint32_t>(-1)));
     341             :   CHECK(!EightBit2::is_valid(static_cast<uint32_t>(-1)));
     342        2565 :   for (unsigned i = 0; i < 256; i++) {
     343        1280 :     CHECK(EightBit1::is_valid(i));
     344             :     x = EightBit1::encode(i);
     345        1280 :     CHECK_EQ(i, EightBit1::decode(x));
     346        1280 :     CHECK(EightBit2::is_valid(i));
     347             :     x = EightBit2::encode(i);
     348        1280 :     CHECK_EQ(i, EightBit2::decode(x));
     349             :   }
     350             :   CHECK(!EightBit1::is_valid(256));
     351             :   CHECK(!EightBit2::is_valid(256));
     352           5 : }
     353             : 
     354             : 
     355             : class UpperBits: public BitField64<int, 61, 3> {};
     356             : class MiddleBits: public BitField64<int, 31, 2> {};
     357             : 
     358       26644 : TEST(BitField64) {
     359             :   uint64_t x;
     360             : 
     361             :   // Test most significant bits.
     362             :   x = V8_2PART_UINT64_C(0xE0000000, 00000000);
     363             :   CHECK(x == UpperBits::encode(7));
     364             :   CHECK_EQ(7, UpperBits::decode(x));
     365             : 
     366             :   // Test the 32/64-bit boundary bits.
     367             :   x = V8_2PART_UINT64_C(0x00000001, 80000000);
     368             :   CHECK(x == MiddleBits::encode(3));
     369             :   CHECK_EQ(3, MiddleBits::decode(x));
     370           5 : }
     371             : 
     372             : 
     373         155 : static void CheckNonArrayIndex(bool expected, const char* chars) {
     374             :   auto isolate = CcTest::i_isolate();
     375         155 :   auto string = isolate->factory()->NewStringFromAsciiChecked(chars);
     376         155 :   CHECK_EQ(expected, IsSpecialIndex(*string));
     377         155 : }
     378             : 
     379             : 
     380       26644 : TEST(SpecialIndexParsing) {
     381             :   auto isolate = CcTest::i_isolate();
     382             :   HandleScope scope(isolate);
     383           5 :   CheckNonArrayIndex(false, "");
     384           5 :   CheckNonArrayIndex(false, "-");
     385           5 :   CheckNonArrayIndex(true, "0");
     386           5 :   CheckNonArrayIndex(true, "-0");
     387           5 :   CheckNonArrayIndex(false, "01");
     388           5 :   CheckNonArrayIndex(false, "-01");
     389           5 :   CheckNonArrayIndex(true, "0.5");
     390           5 :   CheckNonArrayIndex(true, "-0.5");
     391           5 :   CheckNonArrayIndex(true, "1");
     392           5 :   CheckNonArrayIndex(true, "-1");
     393           5 :   CheckNonArrayIndex(true, "10");
     394           5 :   CheckNonArrayIndex(true, "-10");
     395           5 :   CheckNonArrayIndex(true, "NaN");
     396           5 :   CheckNonArrayIndex(true, "Infinity");
     397           5 :   CheckNonArrayIndex(true, "-Infinity");
     398           5 :   CheckNonArrayIndex(true, "4294967295");
     399           5 :   CheckNonArrayIndex(true, "429496.7295");
     400           5 :   CheckNonArrayIndex(true, "1.3333333333333333");
     401           5 :   CheckNonArrayIndex(false, "1.3333333333333339");
     402           5 :   CheckNonArrayIndex(true, "1.333333333333331e+222");
     403           5 :   CheckNonArrayIndex(true, "-1.3333333333333211e+222");
     404           5 :   CheckNonArrayIndex(false, "-1.3333333333333311e+222");
     405           5 :   CheckNonArrayIndex(true, "429496.7295");
     406           5 :   CheckNonArrayIndex(false, "43s3");
     407           5 :   CheckNonArrayIndex(true, "4294967296");
     408           5 :   CheckNonArrayIndex(true, "-4294967296");
     409           5 :   CheckNonArrayIndex(true, "999999999999999");
     410           5 :   CheckNonArrayIndex(false, "9999999999999999");
     411           5 :   CheckNonArrayIndex(true, "-999999999999999");
     412           5 :   CheckNonArrayIndex(false, "-9999999999999999");
     413           5 :   CheckNonArrayIndex(false, "42949672964294967296429496729694966");
     414           5 : }
     415             : 
     416       26644 : TEST(NoHandlesForTryNumberToSize) {
     417             :   i::Isolate* isolate = CcTest::i_isolate();
     418             :   size_t result = 0;
     419             :   {
     420             :     SealHandleScope no_handles(isolate);
     421             :     Smi smi = Smi::FromInt(1);
     422             :     CHECK(TryNumberToSize(smi, &result));
     423             :     CHECK_EQ(result, 1u);
     424             :   }
     425             :   result = 0;
     426             :   {
     427             :     HandleScope scope(isolate);
     428           5 :     Handle<HeapNumber> heap_number1 = isolate->factory()->NewHeapNumber(2.0);
     429             :     {
     430             :       SealHandleScope no_handles(isolate);
     431           5 :       CHECK(TryNumberToSize(*heap_number1, &result));
     432           5 :       CHECK_EQ(result, 2u);
     433             :     }
     434             :     Handle<HeapNumber> heap_number2 = isolate->factory()->NewHeapNumber(
     435           5 :         static_cast<double>(std::numeric_limits<size_t>::max()) + 10000.0);
     436             :     {
     437             :       SealHandleScope no_handles(isolate);
     438           5 :       CHECK(!TryNumberToSize(*heap_number2, &result));
     439             :     }
     440             :   }
     441           5 : }
     442             : 
     443       26644 : TEST(TryNumberToSizeWithMaxSizePlusOne) {
     444             :   i::Isolate* isolate = CcTest::i_isolate();
     445             :   {
     446             :     HandleScope scope(isolate);
     447             :     // 1 << 64, larger than the limit of size_t.
     448             :     double value = 18446744073709551616.0;
     449             :     size_t result = 0;
     450           5 :     Handle<HeapNumber> heap_number = isolate->factory()->NewHeapNumber(value);
     451           5 :     CHECK(!TryNumberToSize(*heap_number, &result));
     452             :   }
     453           5 : }
     454             : 
     455       26644 : TEST(PositiveNumberToUint32) {
     456             :   i::Isolate* isolate = CcTest::i_isolate();
     457             :   i::Factory* factory = isolate->factory();
     458             :   uint32_t max = std::numeric_limits<uint32_t>::max();
     459             :   HandleScope scope(isolate);
     460             :   // Test Smi conversions.
     461             :   Handle<Object> number = handle(Smi::FromInt(0), isolate);
     462           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     463             :   number = handle(Smi::FromInt(-1), isolate);
     464           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     465             :   number = handle(Smi::FromInt(-1), isolate);
     466           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     467             :   number = handle(Smi::FromInt(Smi::kMinValue), isolate);
     468           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     469             :   number = handle(Smi::FromInt(Smi::kMaxValue), isolate);
     470           5 :   CHECK_EQ(PositiveNumberToUint32(*number),
     471             :            static_cast<uint32_t>(Smi::kMaxValue));
     472             :   // Test Double conversions.
     473           5 :   number = factory->NewHeapNumber(0.0);
     474           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     475           5 :   number = factory->NewHeapNumber(0.999);
     476           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     477           5 :   number = factory->NewHeapNumber(1.999);
     478           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 1u);
     479           5 :   number = factory->NewHeapNumber(-12.0);
     480           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     481           5 :   number = factory->NewHeapNumber(12000.0);
     482           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 12000u);
     483           5 :   number = factory->NewHeapNumber(static_cast<double>(Smi::kMaxValue) + 1);
     484           5 :   CHECK_EQ(PositiveNumberToUint32(*number),
     485             :            static_cast<uint32_t>(Smi::kMaxValue) + 1);
     486           5 :   number = factory->NewHeapNumber(max);
     487           5 :   CHECK_EQ(PositiveNumberToUint32(*number), max);
     488           5 :   number = factory->NewHeapNumber(static_cast<double>(max) * 1000);
     489           5 :   CHECK_EQ(PositiveNumberToUint32(*number), max);
     490           5 :   number = factory->NewHeapNumber(std::numeric_limits<double>::max());
     491           5 :   CHECK_EQ(PositiveNumberToUint32(*number), max);
     492           5 :   number = factory->NewHeapNumber(std::numeric_limits<double>::infinity());
     493           5 :   CHECK_EQ(PositiveNumberToUint32(*number), max);
     494             :   number =
     495           5 :       factory->NewHeapNumber(-1.0 * std::numeric_limits<double>::infinity());
     496           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     497           5 :   number = factory->NewHeapNumber(std::nan(""));
     498           5 :   CHECK_EQ(PositiveNumberToUint32(*number), 0u);
     499           5 : }
     500             : 
     501             : }  // namespace internal
     502       79917 : }  // namespace v8

Generated by: LCOV version 1.10