Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 1 | // Copyright 2011 the V8 project authors. All rights reserved. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 27 | |
| 28 | #include <stdlib.h> |
| 29 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 30 | #include "src/v8.h" |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 31 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 32 | #include "src/base/platform/platform.h" |
| 33 | #include "test/cctest/cctest.h" |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 34 | |
| 35 | using namespace v8::internal; |
| 36 | |
| 37 | |
| 38 | TEST(Hex) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 39 | UnicodeCache uc; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 48 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 55 | } |
| 56 | |
| 57 | |
| 58 | TEST(Octal) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 59 | UnicodeCache uc; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 86 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 93 | |
| 94 | const double x = 010000000000; // Power of 2, no rounding errors. |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 95 | CHECK_EQ(x * x * x * x * x, StringToDouble(&uc, "01" "0000000000" "0000000000" |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | |
| 121 | TEST(MalformedOctal) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 122 | UnicodeCache uc; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 126 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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))); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 135 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 138 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 143 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 147 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 152 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 153 | CHECK_EQ(8.7, StringToDouble(&uc, "08.7", ALLOW_HEX)); |
| 154 | CHECK_EQ(8e7, StringToDouble(&uc, "08e7", ALLOW_HEX)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 155 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 156 | CHECK_EQ(0.001, StringToDouble(&uc, "0.001", ALLOW_HEX)); |
| 157 | CHECK_EQ(0.713, StringToDouble(&uc, "0.713", ALLOW_HEX)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | |
| 161 | TEST(TrailingJunk) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 162 | UnicodeCache uc; |
| 163 | CHECK_EQ(8.0, StringToDouble(&uc, "8q", ALLOW_TRAILING_JUNK)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 170 | } |
| 171 | |
| 172 | |
| 173 | TEST(NonStrDecimalLiteral) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 174 | UnicodeCache uc; |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 175 | CHECK(std::isnan( |
| 176 | StringToDouble(&uc, " ", NO_FLAGS, v8::base::OS::nan_value()))); |
| 177 | CHECK( |
| 178 | std::isnan(StringToDouble(&uc, "", NO_FLAGS, v8::base::OS::nan_value()))); |
| 179 | CHECK(std::isnan( |
| 180 | StringToDouble(&uc, " ", NO_FLAGS, v8::base::OS::nan_value()))); |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 181 | CHECK_EQ(0.0, StringToDouble(&uc, "", NO_FLAGS)); |
| 182 | CHECK_EQ(0.0, StringToDouble(&uc, " ", NO_FLAGS)); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 183 | } |
| 184 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 185 | |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 186 | TEST(IntegerStrLiteral) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 196 | CHECK(std::isnan(StringToDouble(&uc, " - 1 ", NO_FLAGS))); |
| 197 | CHECK(std::isnan(StringToDouble(&uc, " + 1 ", NO_FLAGS))); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 198 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 207 | } |
| 208 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 209 | |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 210 | TEST(LongNumberStr) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 211 | UnicodeCache uc; |
| 212 | CHECK_EQ(1e10, StringToDouble(&uc, "1" "0000000000", NO_FLAGS)); |
| 213 | CHECK_EQ(1e20, StringToDouble(&uc, "1" "0000000000" "0000000000", NO_FLAGS)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 214 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 215 | CHECK_EQ(1e60, StringToDouble(&uc, "1" "0000000000" "0000000000" "0000000000" |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 216 | "0000000000" "0000000000" "0000000000", NO_FLAGS)); |
| 217 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 222 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 223 | CHECK_EQ(1e-61, StringToDouble(&uc, "." "0000000000" "0000000000" "0000000000" |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 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, |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 230 | StringToDouble(&uc, "24414062505131250.0", NO_FLAGS)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 231 | |
| 232 | // ... and z = (x + y) / 2 + delta is rounded to y. |
| 233 | CHECK_EQ(24414062505131252.0, |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 234 | StringToDouble(&uc, "24414062505131250.000000001", NO_FLAGS)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 238 | TEST(MaximumSignificantDigits) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 239 | UnicodeCache uc; |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 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 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 255 | CHECK_EQ(4.4501477170144017780491e-308, StringToDouble(&uc, num, NO_FLAGS)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 256 | |
| 257 | // Changes the result of strtod (at least in glibc implementation). |
| 258 | num[sizeof(num) - 8] = '1'; |
| 259 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 260 | CHECK_EQ(4.4501477170144022721148e-308, StringToDouble(&uc, num, NO_FLAGS)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 261 | } |
| 262 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 263 | |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 264 | TEST(MinimumExponent) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 265 | UnicodeCache uc; |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 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 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 282 | CHECK_EQ(4.4501477170144017780491e-308, StringToDouble(&uc, num, NO_FLAGS)); |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 283 | |
| 284 | // Changes the result of strtod (at least in glibc implementation). |
| 285 | num[sizeof(num) - 8] = '1'; |
| 286 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 287 | CHECK_EQ(4.4501477170144022721148e-308, StringToDouble(&uc, num, NO_FLAGS)); |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | |
| 291 | TEST(MaximumExponent) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 292 | UnicodeCache uc; |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 293 | char num[] = "0.16e309"; |
| 294 | |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 295 | CHECK_EQ(1.59999999999999997765e+308, StringToDouble(&uc, num, NO_FLAGS)); |
Ben Murdoch | f87a203 | 2010-10-22 12:50:53 +0100 | [diff] [blame] | 296 | } |
| 297 | |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 298 | |
| 299 | TEST(ExponentNumberStr) { |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 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)); |
Steve Block | 6ded16b | 2010-05-10 14:33:55 +0100 | [diff] [blame] | 307 | } |
| 308 | |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 309 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 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 (int 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 (int 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 | } |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 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 | } |