deps/v8/test/cctest/test-conversions.cc

   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/v8.h"
  31
  32 #include "src/base/platform/platform.h"
  33 #include "test/cctest/cctest.h"
  34
  35 using namespace v8::internal;
  36
  37
  38 TEST(Hex) {
  39   UnicodeCache uc;
  40   CHECK_EQ(0.0, StringToDouble(&uc, "0x0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  41   CHECK_EQ(0.0, StringToDouble(&uc, "0X0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  42   CHECK_EQ(1.0, StringToDouble(&uc, "0x1", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  43   CHECK_EQ(16.0, StringToDouble(&uc, "0x10", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  44   CHECK_EQ(255.0, StringToDouble(&uc, "0xff",
  45                                  ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  46   CHECK_EQ(175.0, StringToDouble(&uc, "0xAF",
  47                                  ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  48
  49   CHECK_EQ(0.0, StringToDouble(&uc, "0x0", ALLOW_HEX));
  50   CHECK_EQ(0.0, StringToDouble(&uc, "0X0", ALLOW_HEX));
  51   CHECK_EQ(1.0, StringToDouble(&uc, "0x1", ALLOW_HEX));
  52   CHECK_EQ(16.0, StringToDouble(&uc, "0x10", ALLOW_HEX));
  53   CHECK_EQ(255.0, StringToDouble(&uc, "0xff", ALLOW_HEX));
  54   CHECK_EQ(175.0, StringToDouble(&uc, "0xAF", ALLOW_HEX));
  55 }
  56
  57
  58 TEST(Octal) {
  59   UnicodeCache uc;
  60   CHECK_EQ(0.0, StringToDouble(&uc, "0o0", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
  61   CHECK_EQ(0.0, StringToDouble(&uc, "0O0", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
  62   CHECK_EQ(1.0, StringToDouble(&uc, "0o1", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
  63   CHECK_EQ(7.0, StringToDouble(&uc, "0o7", ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
  64   CHECK_EQ(8.0, StringToDouble(&uc, "0o10",
  65                                ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
  66   CHECK_EQ(63.0, StringToDouble(&uc, "0o77",
  67                                 ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL));
  68
  69   CHECK_EQ(0.0, StringToDouble(&uc, "0o0", ALLOW_OCTAL));
  70   CHECK_EQ(0.0, StringToDouble(&uc, "0O0", ALLOW_OCTAL));
  71   CHECK_EQ(1.0, StringToDouble(&uc, "0o1", ALLOW_OCTAL));
  72   CHECK_EQ(7.0, StringToDouble(&uc, "0o7", ALLOW_OCTAL));
  73   CHECK_EQ(8.0, StringToDouble(&uc, "0o10", ALLOW_OCTAL));
  74   CHECK_EQ(63.0, StringToDouble(&uc, "0o77", ALLOW_OCTAL));
  75 }
  76
  77
  78 TEST(ImplicitOctal) {
  79   UnicodeCache uc;
  80   CHECK_EQ(0.0, StringToDouble(&uc, "0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  81   CHECK_EQ(0.0, StringToDouble(&uc, "00", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  82   CHECK_EQ(1.0, StringToDouble(&uc, "01", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  83   CHECK_EQ(7.0, StringToDouble(&uc, "07", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  84   CHECK_EQ(8.0, StringToDouble(&uc, "010", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  85   CHECK_EQ(63.0, StringToDouble(&uc, "077", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
  86
  87   CHECK_EQ(0.0, StringToDouble(&uc, "0", ALLOW_HEX));
  88   CHECK_EQ(0.0, StringToDouble(&uc, "00", ALLOW_HEX));
  89   CHECK_EQ(1.0, StringToDouble(&uc, "01", ALLOW_HEX));
  90   CHECK_EQ(7.0, StringToDouble(&uc, "07", ALLOW_HEX));
  91   CHECK_EQ(10.0, StringToDouble(&uc, "010", ALLOW_HEX));
  92   CHECK_EQ(77.0, StringToDouble(&uc, "077", ALLOW_HEX));
  93
  94   const double x = 010000000000;  // Power of 2, no rounding errors.
  95   CHECK_EQ(x * x * x * x * x, StringToDouble(&uc, "01" "0000000000" "0000000000"
  96       "0000000000" "0000000000" "0000000000", ALLOW_IMPLICIT_OCTAL));
  97 }
  98
  99
 100 TEST(Binary) {
 101   UnicodeCache uc;
 102   CHECK_EQ(0.0, StringToDouble(&uc, "0b0",
 103                                ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
 104   CHECK_EQ(0.0, StringToDouble(&uc, "0B0",
 105                                ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
 106   CHECK_EQ(1.0, StringToDouble(&uc, "0b1",
 107                                ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
 108   CHECK_EQ(2.0, StringToDouble(&uc, "0b10",
 109                                ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
 110   CHECK_EQ(3.0, StringToDouble(&uc, "0b11",
 111                                ALLOW_BINARY | ALLOW_IMPLICIT_OCTAL));
 112
 113   CHECK_EQ(0.0, StringToDouble(&uc, "0b0", ALLOW_BINARY));
 114   CHECK_EQ(0.0, StringToDouble(&uc, "0B0", ALLOW_BINARY));
 115   CHECK_EQ(1.0, StringToDouble(&uc, "0b1", ALLOW_BINARY));
 116   CHECK_EQ(2.0, StringToDouble(&uc, "0b10", ALLOW_BINARY));
 117   CHECK_EQ(3.0, StringToDouble(&uc, "0b11", ALLOW_BINARY));
 118 }
 119
 120
 121 TEST(MalformedOctal) {
 122   UnicodeCache uc;
 123   CHECK_EQ(8.0, StringToDouble(&uc, "08", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 124   CHECK_EQ(81.0, StringToDouble(&uc, "081", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 125   CHECK_EQ(78.0, StringToDouble(&uc, "078", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 126
 127   CHECK(std::isnan(StringToDouble(&uc, "07.7",
 128                                   ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
 129   CHECK(std::isnan(StringToDouble(&uc, "07.8",
 130                                   ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
 131   CHECK(std::isnan(StringToDouble(&uc, "07e8",
 132                                   ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
 133   CHECK(std::isnan(StringToDouble(&uc, "07e7",
 134                                   ALLOW_HEX | ALLOW_IMPLICIT_OCTAL)));
 135
 136   CHECK_EQ(8.7, StringToDouble(&uc, "08.7", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 137   CHECK_EQ(8e7, StringToDouble(&uc, "08e7", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 138
 139   CHECK_EQ(0.001, StringToDouble(&uc, "0.001",
 140                                  ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 141   CHECK_EQ(0.713, StringToDouble(&uc, "0.713",
 142                                  ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 143
 144   CHECK_EQ(8.0, StringToDouble(&uc, "08", ALLOW_HEX));
 145   CHECK_EQ(81.0, StringToDouble(&uc, "081", ALLOW_HEX));
 146   CHECK_EQ(78.0, StringToDouble(&uc, "078", ALLOW_HEX));
 147
 148   CHECK_EQ(7.7, StringToDouble(&uc, "07.7", ALLOW_HEX));
 149   CHECK_EQ(7.8, StringToDouble(&uc, "07.8", ALLOW_HEX));
 150   CHECK_EQ(7e8, StringToDouble(&uc, "07e8", ALLOW_HEX));
 151   CHECK_EQ(7e7, StringToDouble(&uc, "07e7", ALLOW_HEX));
 152
 153   CHECK_EQ(8.7, StringToDouble(&uc, "08.7", ALLOW_HEX));
 154   CHECK_EQ(8e7, StringToDouble(&uc, "08e7", ALLOW_HEX));
 155
 156   CHECK_EQ(0.001, StringToDouble(&uc, "0.001", ALLOW_HEX));
 157   CHECK_EQ(0.713, StringToDouble(&uc, "0.713", ALLOW_HEX));
 158 }
 159
 160
 161 TEST(TrailingJunk) {
 162   UnicodeCache uc;
 163   CHECK_EQ(8.0, StringToDouble(&uc, "8q", ALLOW_TRAILING_JUNK));
 164   CHECK_EQ(63.0, StringToDouble(&uc, "077qqq",
 165                                 ALLOW_IMPLICIT_OCTAL | ALLOW_TRAILING_JUNK));
 166   CHECK_EQ(10.0, StringToDouble(&uc, "10e",
 167                                 ALLOW_IMPLICIT_OCTAL | ALLOW_TRAILING_JUNK));
 168   CHECK_EQ(10.0, StringToDouble(&uc, "10e-",
 169                                 ALLOW_IMPLICIT_OCTAL | ALLOW_TRAILING_JUNK));
 170 }
 171
 172
 173 TEST(NonStrDecimalLiteral) {
 174   UnicodeCache uc;
 175   CHECK(std::isnan(StringToDouble(&uc, " ", NO_FLAGS,
 176                                   std::numeric_limits<double>::quiet_NaN())));
 177   CHECK(std::isnan(StringToDouble(&uc, "", NO_FLAGS,
 178                                   std::numeric_limits<double>::quiet_NaN())));
 179   CHECK(std::isnan(StringToDouble(&uc, " ", NO_FLAGS,
 180                                   std::numeric_limits<double>::quiet_NaN())));
 181   CHECK_EQ(0.0, StringToDouble(&uc, "", NO_FLAGS));
 182   CHECK_EQ(0.0, StringToDouble(&uc, " ", NO_FLAGS));
 183 }
 184
 185
 186 TEST(IntegerStrLiteral) {
 187   UnicodeCache uc;
 188   CHECK_EQ(0.0, StringToDouble(&uc, "0.0", NO_FLAGS));
 189   CHECK_EQ(0.0, StringToDouble(&uc, "0", NO_FLAGS));
 190   CHECK_EQ(0.0, StringToDouble(&uc, "00", NO_FLAGS));
 191   CHECK_EQ(0.0, StringToDouble(&uc, "000", NO_FLAGS));
 192   CHECK_EQ(1.0, StringToDouble(&uc, "1", NO_FLAGS));
 193   CHECK_EQ(-1.0, StringToDouble(&uc, "-1", NO_FLAGS));
 194   CHECK_EQ(-1.0, StringToDouble(&uc, "  -1  ", NO_FLAGS));
 195   CHECK_EQ(1.0, StringToDouble(&uc, "  +1  ", NO_FLAGS));
 196   CHECK(std::isnan(StringToDouble(&uc, "  -  1  ", NO_FLAGS)));
 197   CHECK(std::isnan(StringToDouble(&uc, "  +  1  ", NO_FLAGS)));
 198
 199   CHECK_EQ(0.0, StringToDouble(&uc, "0e0", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 200   CHECK_EQ(0.0, StringToDouble(&uc, "0e1", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 201   CHECK_EQ(0.0, StringToDouble(&uc, "0e-1", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 202   CHECK_EQ(0.0, StringToDouble(&uc, "0e-100000",
 203                                ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 204   CHECK_EQ(0.0, StringToDouble(&uc, "0e+100000",
 205                                ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 206   CHECK_EQ(0.0, StringToDouble(&uc, "0.", ALLOW_HEX | ALLOW_IMPLICIT_OCTAL));
 207 }
 208
 209
 210 TEST(LongNumberStr) {
 211   UnicodeCache uc;
 212   CHECK_EQ(1e10, StringToDouble(&uc, "1" "0000000000", NO_FLAGS));
 213   CHECK_EQ(1e20, StringToDouble(&uc, "1" "0000000000" "0000000000", NO_FLAGS));
 214
 215   CHECK_EQ(1e60, StringToDouble(&uc, "1" "0000000000" "0000000000" "0000000000"
 216       "0000000000" "0000000000" "0000000000", NO_FLAGS));
 217
 218   CHECK_EQ(1e-2, StringToDouble(&uc, "." "0" "1", NO_FLAGS));
 219   CHECK_EQ(1e-11, StringToDouble(&uc, "." "0000000000" "1", NO_FLAGS));
 220   CHECK_EQ(1e-21, StringToDouble(&uc, "." "0000000000" "0000000000" "1",
 221                                  NO_FLAGS));
 222
 223   CHECK_EQ(1e-61, StringToDouble(&uc, "." "0000000000" "0000000000" "0000000000"
 224       "0000000000" "0000000000" "0000000000" "1", NO_FLAGS));
 225
 226
 227   // x = 24414062505131248.0 and y = 24414062505131252.0 are representable in
 228   // double. Check chat z = (x + y) / 2 is rounded to x...
 229   CHECK_EQ(24414062505131248.0,
 230            StringToDouble(&uc, "24414062505131250.0", NO_FLAGS));
 231
 232   // ... and z = (x + y) / 2 + delta is rounded to y.
 233   CHECK_EQ(24414062505131252.0,
 234            StringToDouble(&uc, "24414062505131250.000000001", NO_FLAGS));
 235 }
 236
 237
 238 TEST(MaximumSignificantDigits) {
 239   UnicodeCache uc;
 240   char num[] =
 241       "4.4501477170144020250819966727949918635852426585926051135169509"
 242       "122872622312493126406953054127118942431783801370080830523154578"
 243       "251545303238277269592368457430440993619708911874715081505094180"
 244       "604803751173783204118519353387964161152051487413083163272520124"
 245       "606023105869053620631175265621765214646643181420505164043632222"
 246       "668006474326056011713528291579642227455489682133472873831754840"
 247       "341397809846934151055619529382191981473003234105366170879223151"
 248       "087335413188049110555339027884856781219017754500629806224571029"
 249       "581637117459456877330110324211689177656713705497387108207822477"
 250       "584250967061891687062782163335299376138075114200886249979505279"
 251       "101870966346394401564490729731565935244123171539810221213221201"
 252       "847003580761626016356864581135848683152156368691976240370422601"
 253       "6998291015625000000000000000000000000000000000e-308";
 254
 255   CHECK_EQ(4.4501477170144017780491e-308, StringToDouble(&uc, num, NO_FLAGS));
 256
 257   // Changes the result of strtod (at least in glibc implementation).
 258   num[sizeof(num) - 8] = '1';
 259
 260   CHECK_EQ(4.4501477170144022721148e-308, StringToDouble(&uc, num, NO_FLAGS));
 261 }
 262
 263
 264 TEST(MinimumExponent) {
 265   UnicodeCache uc;
 266   // Same test but with different point-position.
 267   char num[] =
 268   "445014771701440202508199667279499186358524265859260511351695091"
 269   "228726223124931264069530541271189424317838013700808305231545782"
 270   "515453032382772695923684574304409936197089118747150815050941806"
 271   "048037511737832041185193533879641611520514874130831632725201246"
 272   "060231058690536206311752656217652146466431814205051640436322226"
 273   "680064743260560117135282915796422274554896821334728738317548403"
 274   "413978098469341510556195293821919814730032341053661708792231510"
 275   "873354131880491105553390278848567812190177545006298062245710295"
 276   "816371174594568773301103242116891776567137054973871082078224775"
 277   "842509670618916870627821633352993761380751142008862499795052791"
 278   "018709663463944015644907297315659352441231715398102212132212018"
 279   "470035807616260163568645811358486831521563686919762403704226016"
 280   "998291015625000000000000000000000000000000000e-1108";
 281
 282   CHECK_EQ(4.4501477170144017780491e-308, StringToDouble(&uc, num, NO_FLAGS));
 283
 284   // Changes the result of strtod (at least in glibc implementation).
 285   num[sizeof(num) - 8] = '1';
 286
 287   CHECK_EQ(4.4501477170144022721148e-308, StringToDouble(&uc, num, NO_FLAGS));
 288 }
 289
 290
 291 TEST(MaximumExponent) {
 292   UnicodeCache uc;
 293   char num[] = "0.16e309";
 294
 295   CHECK_EQ(1.59999999999999997765e+308, StringToDouble(&uc, num, NO_FLAGS));
 296 }
 297
 298
 299 TEST(ExponentNumberStr) {
 300   UnicodeCache uc;
 301   CHECK_EQ(1e1, StringToDouble(&uc, "1e1", NO_FLAGS));
 302   CHECK_EQ(1e1, StringToDouble(&uc, "1e+1", NO_FLAGS));
 303   CHECK_EQ(1e-1, StringToDouble(&uc, "1e-1", NO_FLAGS));
 304   CHECK_EQ(1e100, StringToDouble(&uc, "1e+100", NO_FLAGS));
 305   CHECK_EQ(1e-100, StringToDouble(&uc, "1e-100", NO_FLAGS));
 306   CHECK_EQ(1e-106, StringToDouble(&uc, ".000001e-100", NO_FLAGS));
 307 }
 308
 309
 310 class OneBit1: public BitField<uint32_t, 0, 1> {};
 311 class OneBit2: public BitField<uint32_t, 7, 1> {};
 312 class EightBit1: public BitField<uint32_t, 0, 8> {};
 313 class EightBit2: public BitField<uint32_t, 13, 8> {};
 314
 315 TEST(BitField) {
 316   uint32_t x;
 317
 318   // One bit bit field can hold values 0 and 1.
 319   CHECK(!OneBit1::is_valid(static_cast<uint32_t>(-1)));
 320   CHECK(!OneBit2::is_valid(static_cast<uint32_t>(-1)));
 321   for (unsigned i = 0; i < 2; i++) {
 322     CHECK(OneBit1::is_valid(i));
 323     x = OneBit1::encode(i);
 324     CHECK_EQ(i, OneBit1::decode(x));
 325
 326     CHECK(OneBit2::is_valid(i));
 327     x = OneBit2::encode(i);
 328     CHECK_EQ(i, OneBit2::decode(x));
 329   }
 330   CHECK(!OneBit1::is_valid(2));
 331   CHECK(!OneBit2::is_valid(2));
 332
 333   // Eight bit bit field can hold values from 0 tp 255.
 334   CHECK(!EightBit1::is_valid(static_cast<uint32_t>(-1)));
 335   CHECK(!EightBit2::is_valid(static_cast<uint32_t>(-1)));
 336   for (unsigned i = 0; i < 256; i++) {
 337     CHECK(EightBit1::is_valid(i));
 338     x = EightBit1::encode(i);
 339     CHECK_EQ(i, EightBit1::decode(x));
 340     CHECK(EightBit2::is_valid(i));
 341     x = EightBit2::encode(i);
 342     CHECK_EQ(i, EightBit2::decode(x));
 343   }
 344   CHECK(!EightBit1::is_valid(256));
 345   CHECK(!EightBit2::is_valid(256));
 346 }
 347
 348
 349 class UpperBits: public BitField64<int, 61, 3> {};
 350 class MiddleBits: public BitField64<int, 31, 2> {};
 351
 352 TEST(BitField64) {
 353   uint64_t x;
 354
 355   // Test most significant bits.
 356   x = V8_2PART_UINT64_C(0xE0000000, 00000000);
 357   CHECK(x == UpperBits::encode(7));
 358   CHECK_EQ(7, UpperBits::decode(x));
 359
 360   // Test the 32/64-bit boundary bits.
 361   x = V8_2PART_UINT64_C(0x00000001, 80000000);
 362   CHECK(x == MiddleBits::encode(3));
 363   CHECK_EQ(3, MiddleBits::decode(x));
 364 }
 365
 366
 367 static void CheckNonArrayIndex(bool expected, const char* chars) {
 368   auto isolate = CcTest::i_isolate();
 369   auto string = isolate->factory()->NewStringFromAsciiChecked(chars);
 370   CHECK_EQ(expected, IsNonArrayIndexInteger(*string));
 371 }
 372
 373
 374 TEST(NonArrayIndexParsing) {
 375   auto isolate = CcTest::i_isolate();
 376   HandleScope scope(isolate);
 377   CheckNonArrayIndex(false, "");
 378   CheckNonArrayIndex(false, "-");
 379   CheckNonArrayIndex(false, "0");
 380   CheckNonArrayIndex(false, "01");
 381   CheckNonArrayIndex(false, "-01");
 382   CheckNonArrayIndex(false, "4294967295");
 383   CheckNonArrayIndex(false, "429496.7295");
 384   CheckNonArrayIndex(false, "43s3");
 385   CheckNonArrayIndex(true, "-0");
 386   CheckNonArrayIndex(true, "-1");
 387   CheckNonArrayIndex(true, "4294967296");
 388   CheckNonArrayIndex(true, "-4294967296");
 389   CheckNonArrayIndex(
 390       true,
 391       "429496729642949672964294967296429496729642949672964294967296"
 392       "429496729642949672964294967296429496729642949672964294967296"
 393       "429496729642949672964294967296429496729642949672964294967296"
 394       "429496729642949672964294967296429496729642949672964294967296"
 395       "429496729642949672964294967296429496729642949672964294967296"
 396       "429496729642949672964294967296429496729642949672964294967296"
 397       "429496729642949672964294967296429496729642949672964294967296"
 398       "429496729642949672964294967296429496729642949672964294967296"
 399       "429496729642949672964294967296429496729642949672964294967296"
 400       "429496729642949672964294967296429496729642949672964294967296"
 401       "429496729642949672964294967296429496729642949672964294967296"
 402       "429496729642949672964294967296429496729642949672964294967296"
 403       "429496729642949672964294967296429496729642949672964294967296");
 404   CheckNonArrayIndex(
 405       true,
 406       "-429496729642949672964294967296429496729642949672964294967296"
 407       "429496729642949672964294967296429496729642949672964294967296"
 408       "429496729642949672964294967296429496729642949672964294967296"
 409       "429496729642949672964294967296429496729642949672964294967296"
 410       "429496729642949672964294967296429496729642949672964294967296"
 411       "429496729642949672964294967296429496729642949672964294967296"
 412       "429496729642949672964294967296429496729642949672964294967296"
 413       "429496729642949672964294967296429496729642949672964294967296"
 414       "429496729642949672964294967296429496729642949672964294967296"
 415       "429496729642949672964294967296429496729642949672964294967296"
 416       "429496729642949672964294967296429496729642949672964294967296"
 417       "429496729642949672964294967296429496729642949672964294967296"
 418       "429496729642949672964294967296429496729642949672964294967296");
 419 }