1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "common_components/objects/string_table/integer_cache.h"
17 #include "ecmascript/base/number_helper.h"
18 #include "ecmascript/tests/test_helper.h"
19
20 using namespace panda::ecmascript;
21 using namespace panda::ecmascript::base;
22
23 namespace panda::test {
24 class NumberHelperTest : public BaseTestWithScope<false> {
25 };
26
27 /**
28 * @tc.name: IsNaN
29 * @tc.desc: Check whether number is Nan type data through "IsNaN" function.
30 * @tc.type: FUNC
31 * @tc.require:
32 */
HWTEST_F_L0(NumberHelperTest,IsNaN)33 HWTEST_F_L0(NumberHelperTest, IsNaN)
34 {
35 JSTaggedValue number1(1.23);
36 EXPECT_FALSE(NumberHelper::IsNaN(number1));
37
38 JSTaggedValue number2(-1.23);
39 EXPECT_FALSE(NumberHelper::IsNaN(number2));
40
41 JSTaggedValue number3(0.0f);
42 EXPECT_FALSE(NumberHelper::IsNaN(number3));
43
44 JSTaggedValue number4(0.0f / 0.0f);
45 EXPECT_TRUE(NumberHelper::IsNaN(number4));
46
47 JSTaggedValue number5(NAN_VALUE);
48 EXPECT_TRUE(NumberHelper::IsNaN(number5));
49 }
50
51 /**
52 * @tc.name: DoubleToString
53 * @tc.desc: This function Convert the double type data into a string.first convert it into the corresponding
54 * hexadecimal number according to the transmitted radix, and convert the hexadecimal number into a
55 * string.
56 * @tc.type: FUNC
57 * @tc.require:
58 */
HWTEST_F_L0(NumberHelperTest,DoubleToString_001)59 HWTEST_F_L0(NumberHelperTest, DoubleToString_001)
60 {
61 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
62 int radix;
63 radix = 2;
64 JSHandle<EcmaString> resultStr = factory->NewFromASCII("100101");
65 JSHandle<EcmaString> handleEcmaStr1(thread, NumberHelper::DoubleToString(thread, 37, radix));
66 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr1, resultStr), 0);
67
68 radix = 3;
69 resultStr = factory->NewFromASCII("-1101");
70 JSHandle<EcmaString> handleEcmaStr2(thread, NumberHelper::DoubleToString(thread, -37, radix));
71 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr2, resultStr), 0);
72
73 radix = 4;
74 resultStr = factory->NewFromASCII("211");
75 JSHandle<EcmaString> handleEcmaStr3(thread, NumberHelper::DoubleToString(thread, 37, radix));
76 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr3, resultStr), 0);
77
78 radix = 5;
79 resultStr = factory->NewFromASCII("122");
80 JSHandle<EcmaString> handleEcmaStr4(thread, NumberHelper::DoubleToString(thread, 37, radix));
81 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr4, resultStr), 0);
82
83 radix = 5;
84 resultStr = factory->NewFromASCII("-1104332401304422434310320000");
85 JSHandle<EcmaString> handleEcmaStr5(thread,
86 NumberHelper::DoubleToString(thread, static_cast<double>(-9223372036854775807), radix));
87 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr5, resultStr), 0);
88
89 radix = 6;
90 resultStr = factory->NewFromASCII("101");
91 JSHandle<EcmaString> handleEcmaStr6(thread, NumberHelper::DoubleToString(thread, 37, radix));
92 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr6, resultStr), 0);
93
94 radix = 7;
95 resultStr = factory->NewFromASCII("52");
96 JSHandle<EcmaString> handleEcmaStr7(thread, NumberHelper::DoubleToString(thread, 37, radix));
97 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr7, resultStr), 0);
98
99 radix = 36;
100 resultStr = factory->NewFromASCII("11");
101 JSHandle<EcmaString> handleEcmaStr8(thread, NumberHelper::DoubleToString(thread, 37, radix));
102 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr8, resultStr), 0);
103 }
104
HWTEST_F_L0(NumberHelperTest,DoubleToString_002)105 HWTEST_F_L0(NumberHelperTest, DoubleToString_002)
106 {
107 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
108 int radix = 2;
109
110 JSHandle<EcmaString> resultStr =
111 factory->NewFromASCII("10.111111011011000110000101010010001010100110111101");
112 JSHandle<EcmaString> handleEcmaStr1(thread, NumberHelper::DoubleToString(thread, 2.99099, radix));
113 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr1, resultStr), 0);
114
115 resultStr = factory->NewFromASCII("10.000000101001000000000011111011101010001000001001101");
116 JSHandle<EcmaString> handleEcmaStr2(thread, NumberHelper::DoubleToString(thread, 2.01001, radix));
117 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr2, resultStr), 0);
118
119 resultStr = factory->NewFromASCII("10.100000000000011010001101101110001011101011000111001");
120 JSHandle<EcmaString> handleEcmaStr3(thread, NumberHelper::DoubleToString(thread, 2.5001, radix));
121 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr3, resultStr), 0);
122
123 radix = 36;
124 resultStr = factory->NewFromASCII("0.i04nym8equ");
125 JSHandle<EcmaString> handleEcmaStr4(thread, NumberHelper::DoubleToString(thread, 0.5001, radix));
126 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr4, resultStr), 0);
127
128 resultStr = factory->NewFromASCII("0.wej2d0mt58f");
129 JSHandle<EcmaString> handleEcmaStr5(thread, NumberHelper::DoubleToString(thread, 0.9001, radix));
130 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr5, resultStr), 0);
131
132 resultStr = factory->NewFromASCII("0.0d384dldb02");
133 JSHandle<EcmaString> handleEcmaStr6(thread, NumberHelper::DoubleToString(thread, 0.0101, radix));
134 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr6, resultStr), 0);
135 }
136
137 /**
138 * @tc.name: DoubleToCString
139 * @tc.desc: This function Convert the double type data into a CString.
140 * @tc.type: FUNC
141 * @tc.require:
142 */
HWTEST_F_L0(NumberHelperTest,DoubleToCString)143 HWTEST_F_L0(NumberHelperTest, DoubleToCString)
144 {
145 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
146
147 JSHandle<EcmaString> resultStr1 =
148 factory->NewFromASCII("5562684646268003");
149 double d1 = 5562684646268003;
150 JSHandle<EcmaString> resultJSHandle1 = factory->NewFromASCII(NumberHelper::DoubleToCString(d1));
151 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle1, resultStr1), 0);
152
153 JSHandle<EcmaString> resultStr2 =
154 factory->NewFromASCII("0.005431");
155 double d2 = 0.005431;
156 JSHandle<EcmaString> resultJSHandle2 = factory->NewFromASCII(NumberHelper::DoubleToCString(d2));
157 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle2, resultStr2), 0);
158
159 JSHandle<EcmaString> resultStr3 =
160 factory->NewFromASCII("1.9045e-7");
161 double d3 = 0.00000019045;
162 JSHandle<EcmaString> resultJSHandle3 = factory->NewFromASCII(NumberHelper::DoubleToCString(d3));
163 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle3, resultStr3), 0);
164
165 JSHandle<EcmaString> resultStr4 =
166 factory->NewFromASCII("-79.39773355813419");
167 double d4 = -79.39773355813419;
168 JSHandle<EcmaString> resultJSHandle4 = factory->NewFromASCII(NumberHelper::DoubleToCString(d4));
169 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle4, resultStr4), 0);
170
171 JSHandle<EcmaString> resultStr5 =
172 factory->NewFromASCII("1e+21");
173 double d5 = 1e21;
174 JSHandle<EcmaString> resultJSHandle5 = factory->NewFromASCII(NumberHelper::DoubleToCString(d5));
175 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle5, resultStr5), 0);
176
177 JSHandle<EcmaString> resultStr6 =
178 factory->NewFromASCII("340000000000000000");
179 double d6 = 340000000000000000;
180 JSHandle<EcmaString> resultJSHandle6 = factory->NewFromASCII(NumberHelper::DoubleToCString(d6));
181 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle6, resultStr6), 0);
182
183 JSHandle<EcmaString> resultStr7 =
184 factory->NewFromASCII("12.012345678901234");
185 double d7 = 12.01234567890123456789;
186 JSHandle<EcmaString> resultJSHandle7 = factory->NewFromASCII(NumberHelper::DoubleToCString(d7));
187 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle7, resultStr7), 0);
188
189 JSHandle<EcmaString> resultStr8 =
190 factory->NewFromASCII("0.0000012345678901234567");
191 double digit8 = 0.000001234567890123456789;
192 JSHandle<EcmaString> resultJSHandle8 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit8));
193 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle8, resultStr8), 0);
194
195 JSHandle<EcmaString> resultStr9 =
196 factory->NewFromASCII("Infinity");
197 double digit9 = std::numeric_limits<double>::infinity();
198 JSHandle<EcmaString> resultJSHandle9 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit9));
199 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle9, resultStr9), 0);
200
201 JSHandle<EcmaString> resultStr10 =
202 factory->NewFromASCII("-Infinity");
203 double digit10 = -std::numeric_limits<double>::infinity();
204 JSHandle<EcmaString> resultJSHandle10 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit10));
205 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle10, resultStr10), 0);
206
207 JSHandle<EcmaString> resultStr11 =
208 factory->NewFromASCII("1.7976931348623157e+308");
209 double digit11 = 1.797693134862315807937e+308;
210 JSHandle<EcmaString> resultJSHandle11 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit11));
211 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle11, resultStr11), 0);
212
213 JSHandle<EcmaString> resultStr12 =
214 factory->NewFromASCII("-1.7976931348623157e+308");
215 double digit12 = -1.797693134862315807937e+308;
216 JSHandle<EcmaString> resultJSHandle12 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit12));
217 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle12, resultStr12), 0);
218
219 JSHandle<EcmaString> resultStr13 =
220 factory->NewFromASCII("2.22507e-308");
221 double digit13 = 2.22507e-308;
222 JSHandle<EcmaString> resultJSHandle13 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit13));
223 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle13, resultStr13), 0);
224
225 JSHandle<EcmaString> resultStr14 =
226 factory->NewFromASCII("1.2345678901234568e-7");
227 double digit14 = 0.0000001234567890123456789;
228 JSHandle<EcmaString> resultJSHandle14 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit14));
229 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle14, resultStr14), 0);
230
231 JSHandle<EcmaString> resultStr15 =
232 factory->NewFromASCII("3.4e+21");
233 double digit15 = 3.4e21;
234 JSHandle<EcmaString> resultJSHandle15 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit15));
235 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle15, resultStr15), 0);
236
237 JSHandle<EcmaString> resultStr16 =
238 factory->NewFromASCII("120000000000000000000");
239 double digit16 = 1.2e20;
240 JSHandle<EcmaString> resultJSHandle16 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit16));
241 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle16, resultStr16), 0);
242
243 JSHandle<EcmaString> resultStr17 =
244 factory->NewFromASCII("1.2");
245 double digit17 = 1.2e0;
246 JSHandle<EcmaString> resultJSHandle17 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit17));
247 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle17, resultStr17), 0);
248
249 JSHandle<EcmaString> resultStr18 =
250 factory->NewFromASCII("0.0000012");
251 double digit18 = 1.2e-6;
252 JSHandle<EcmaString> resultJSHandle18 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit18));
253 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle18, resultStr18), 0);
254
255 JSHandle<EcmaString> resultStr19 =
256 factory->NewFromASCII("1.2e-7");
257 double digit19 = 1.2e-7;
258 JSHandle<EcmaString> resultJSHandle19 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit19));
259 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle19, resultStr19), 0);
260
261 JSHandle<EcmaString> resultStr20 =
262 factory->NewFromASCII("NaN");
263 double digit20 = std::numeric_limits<double>::quiet_NaN();
264 JSHandle<EcmaString> resultJSHandle20 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit20));
265 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle20, resultStr20), 0);
266
267 JSHandle<EcmaString> resultStr21 =
268 factory->NewFromASCII("-12.012345678901234");
269 double digit21 = -12.01234567890123456789;
270 JSHandle<EcmaString> resultJSHandle21 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit21));
271 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle21, resultStr21), 0);
272
273 JSHandle<EcmaString> resultStr22 =
274 factory->NewFromASCII("-0.0000012345678901234567");
275 double digit22 = -0.000001234567890123456789;
276 JSHandle<EcmaString> resultJSHandle22 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit22));
277 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle22, resultStr22), 0);
278
279 JSHandle<EcmaString> resultStr23 =
280 factory->NewFromASCII("-1.2345678901234568e-7");
281 double digit23 = -0.0000001234567890123456789;
282 JSHandle<EcmaString> resultJSHandle23 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit23));
283 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle23, resultStr23), 0);
284
285 JSHandle<EcmaString> resultStr24 =
286 factory->NewFromASCII("-3.4e+21");
287 double digit24 = -3.4e21;
288 JSHandle<EcmaString> resultJSHandle24 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit24));
289 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle24, resultStr24), 0);
290
291 JSHandle<EcmaString> resultStr25 =
292 factory->NewFromASCII("-120000000000000000000");
293 double digit25 = -1.2e20;
294 JSHandle<EcmaString> resultJSHandle25 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit25));
295 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle25, resultStr25), 0);
296
297 JSHandle<EcmaString> resultStr26 =
298 factory->NewFromASCII("-1.2");
299 double digit26 = -1.2e0;
300 JSHandle<EcmaString> resultJSHandle26 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit26));
301 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle26, resultStr26), 0);
302
303 JSHandle<EcmaString> resultStr27 =
304 factory->NewFromASCII("-0.0000012");
305 double digit27 = -1.2e-6;
306 JSHandle<EcmaString> resultJSHandle27 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit27));
307 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle27, resultStr27), 0);
308
309 JSHandle<EcmaString> resultStr28 =
310 factory->NewFromASCII("-1.2e-7");
311 double digit28 = -1.2e-7;
312 JSHandle<EcmaString> resultJSHandle28 = factory->NewFromASCII(NumberHelper::DoubleToCString(digit28));
313 EXPECT_EQ(EcmaStringAccessor::Compare(instance, resultJSHandle28, resultStr28), 0);
314 }
315
316 /**
317 * @tc.name: IsEmptyString
318 * @tc.desc: Check whether the character is empty string through "IsEmptyString" function.
319 * @tc.type: FUNC
320 * @tc.require:
321 */
HWTEST_F_L0(NumberHelperTest,IsEmptyString_001)322 HWTEST_F_L0(NumberHelperTest, IsEmptyString_001)
323 {
324 // 9 ~ 13 and 32 belong to empty string
325 uint8_t a[] = {0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x20};
326 for (int i = 0; i < static_cast<int>(sizeof(a)); i++) {
327 EXPECT_TRUE(NumberHelper::IsEmptyString(&a[i], &a[i] + 1));
328 }
329 }
330
HWTEST_F_L0(NumberHelperTest,IsEmptyString_002)331 HWTEST_F_L0(NumberHelperTest, IsEmptyString_002)
332 {
333 // 14 ~ 31 not belong to empty string
334 uint8_t a[] = {0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
335 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F};
336 for (int i = 0; i < static_cast<int>(sizeof(a)); i++) {
337 EXPECT_FALSE(NumberHelper::IsEmptyString(&a[i], &a[i] + 1));
338 }
339 }
340
HWTEST_F_L0(NumberHelperTest,IsEmptyString_003)341 HWTEST_F_L0(NumberHelperTest, IsEmptyString_003)
342 {
343 // 0 ~ 8 not belong to empty string
344 uint8_t a[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
345 for (int i = 0; i < static_cast<int>(sizeof(a)); i++) {
346 EXPECT_FALSE(NumberHelper::IsEmptyString(&a[i], &a[i] + 1));
347 }
348 }
349
HWTEST_F_L0(NumberHelperTest,IsEmptyString_004)350 HWTEST_F_L0(NumberHelperTest, IsEmptyString_004)
351 {
352 // 160 belong to empty string
353 uint16_t c = 160;
354 common::utf_helper::Utf8Char d = common::utf_helper::ConvertUtf16ToUtf8(c, 0, true);
355 EXPECT_EQ(d.ch.at(1), 160);
356 uint8_t b = d.ch.at(1);
357 EXPECT_TRUE(NumberHelper::IsEmptyString(&b, &b + 1));
358 }
359
360 /**
361 * @tc.name: TruncateDouble
362 * @tc.desc:This function takes the integer part of double type.When it is positive,it is rounded down
363 * When it is negative,it is rounded up.
364 * @tc.type: FUNC
365 * @tc.require:
366 */
HWTEST_F_L0(NumberHelperTest,TruncateDouble)367 HWTEST_F_L0(NumberHelperTest, TruncateDouble)
368 {
369 EXPECT_EQ(NumberHelper::TruncateDouble(NAN_VALUE), 0);
370 EXPECT_EQ(NumberHelper::TruncateDouble(POSITIVE_INFINITY), POSITIVE_INFINITY);
371 // round down
372 EXPECT_EQ(NumberHelper::TruncateDouble(4.1), 4);
373 EXPECT_EQ(NumberHelper::TruncateDouble(4.9), 4);
374 EXPECT_EQ(NumberHelper::TruncateDouble(101.111), 101);
375 EXPECT_EQ(NumberHelper::TruncateDouble(101.999), 101);
376 // round up
377 EXPECT_EQ(NumberHelper::TruncateDouble(-4.1), -4);
378 EXPECT_EQ(NumberHelper::TruncateDouble(-4.9), -4);
379 EXPECT_EQ(NumberHelper::TruncateDouble(-101.111), -101);
380 EXPECT_EQ(NumberHelper::TruncateDouble(-101.999), -101);
381 }
382
383 /**
384 * @tc.name: DoubleToInt
385 * @tc.desc: This function takes the double of integer type.When the decimal part is eight and the number of digits
386 * is 15 ~ 16, add one to convert to integer.According to the binary digits of the integer part,it is divided
387 * into 8, 16 and 64 hexadecimal conversion,for example, 8-hexadecimal conversion.The maximum value of the
388 * integer part is 255. If it exceeds 255,the conversion fails.
389 * @tc.type: FUNC
390 * @tc.require:
391 */
HWTEST_F_L0(NumberHelperTest,DoubleToInt_001)392 HWTEST_F_L0(NumberHelperTest, DoubleToInt_001)
393 {
394 EXPECT_EQ(NumberHelper::DoubleToInt(9.0, INT8_BITS), 9);
395 EXPECT_EQ(NumberHelper::DoubleToInt(9.5555555555555559, INT8_BITS), 9);
396 EXPECT_EQ(NumberHelper::DoubleToInt(9.9999999999999999, INT8_BITS), 10);
397 EXPECT_EQ(NumberHelper::DoubleToInt(128.123456, INT8_BITS), 128);
398 EXPECT_EQ(NumberHelper::DoubleToInt(-128.987654321, INT8_BITS), -128);
399
400 // the exponential bit digits exceeds 7
401 EXPECT_EQ(NumberHelper::DoubleToInt(256.0, INT8_BITS), 0);
402 EXPECT_EQ(NumberHelper::DoubleToInt(-256.0, INT8_BITS), 0);
403
404 double nanDouble = 0.0f / 0.0f;
405 EXPECT_EQ(NumberHelper::DoubleToInt(nanDouble, INT8_BITS), 0);
406 double infDouble = POSITIVE_INFINITY;
407 EXPECT_EQ(NumberHelper::DoubleToInt(infDouble, INT8_BITS), 0);
408 }
409
HWTEST_F_L0(NumberHelperTest,DoubleToInt_002)410 HWTEST_F_L0(NumberHelperTest, DoubleToInt_002)
411 {
412 EXPECT_EQ(NumberHelper::DoubleToInt(256.0, INT16_BITS), 256);
413 EXPECT_EQ(NumberHelper::DoubleToInt(256.555555555555556, INT16_BITS), 256);
414 EXPECT_EQ(NumberHelper::DoubleToInt(256.999999999999999, INT16_BITS), 257);
415 EXPECT_EQ(NumberHelper::DoubleToInt(1024.56789, INT16_BITS), 1024);
416 EXPECT_EQ(NumberHelper::DoubleToInt(-1024.987654, INT16_BITS), -1024);
417
418 // the exponential bit digits exceeds 15
419 EXPECT_EQ(NumberHelper::DoubleToInt(65536.0, INT16_BITS), 0);
420 EXPECT_EQ(NumberHelper::DoubleToInt(-65536.0, INT16_BITS), 0);
421
422 double nanDouble = 0.0f / 0.0f;
423 EXPECT_EQ(NumberHelper::DoubleToInt(nanDouble, INT16_BITS), 0);
424 double infDouble = POSITIVE_INFINITY;
425 EXPECT_EQ(NumberHelper::DoubleToInt(infDouble, INT16_BITS), 0);
426 }
427
HWTEST_F_L0(NumberHelperTest,DoubleToInt_003)428 HWTEST_F_L0(NumberHelperTest, DoubleToInt_003)
429 {
430 EXPECT_EQ(NumberHelper::DoubleToInt(256.0, INT64_BITS), 256);
431 EXPECT_EQ(NumberHelper::DoubleToInt(256.555555555555556, INT64_BITS), 256);
432 EXPECT_EQ(NumberHelper::DoubleToInt(256.999999999999999, INT64_BITS), 257);
433 EXPECT_EQ(NumberHelper::DoubleToInt(65536.55555, INT64_BITS), 65536);
434 EXPECT_EQ(NumberHelper::DoubleToInt(-65536.99999, INT64_BITS), -65536);
435
436 EXPECT_EQ(NumberHelper::DoubleToInt(2147483647.0, INT64_BITS), 2147483647);
437 EXPECT_EQ(NumberHelper::DoubleToInt(-2147483647.0, INT64_BITS), -2147483647);
438
439 double nanDouble = 0.0f / 0.0f;
440 EXPECT_EQ(NumberHelper::DoubleToInt(nanDouble, INT64_BITS), 0);
441 double infDouble = POSITIVE_INFINITY;
442 EXPECT_EQ(NumberHelper::DoubleToInt(infDouble, INT64_BITS), 0);
443 }
444
445 /**
446 * @tc.name: DoubleInRangeInt32
447 * @tc.desc: The function is to convert double type to int type,The maximum value of integer part of double type
448 * cannot exceed the maximum value of int, and the minimum value of integer part cannot exceed the
449 * minimum value of int.
450 * @tc.type: FUNC
451 * @tc.require:
452 */
HWTEST_F_L0(NumberHelperTest,DoubleInRangeInt32)453 HWTEST_F_L0(NumberHelperTest, DoubleInRangeInt32)
454 {
455 // more than INT_MAX
456 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(2147483649.0), 2147483647);
457 // less than INT_MIN
458 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(-2147483649.0), -2147483648);
459
460 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(128.0), 128);
461 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(-128.999999999999999), -129);
462 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(256.0), 256);
463 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(-256.0), -256);
464 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(12345.6789), 12345);
465 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(-12345.6789), -12345);
466 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(65535.999999999999999), 65536);
467 EXPECT_EQ(NumberHelper::DoubleInRangeInt32(-65535), -65535);
468 }
469
470 /**
471 * @tc.name: DoubleToExponential
472 * @tc.desc: Convert integer type to string type through "DoubleToExponential" function.
473 * @tc.type: FUNC
474 * @tc.require:
475 */
HWTEST_F_L0(NumberHelperTest,DoubleToExponential01)476 HWTEST_F_L0(NumberHelperTest, DoubleToExponential01)
477 {
478 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
479 int radix;
480
481 radix = 0;
482 JSHandle<EcmaString> resultStr = factory->NewFromASCII("1.12356e-4");
483 JSHandle<EcmaString> handleEcmaStr1(thread, NumberHelper::DoubleToExponential(thread,
484 0.00011235600000000001, radix));
485 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr1, resultStr), 0);
486
487 radix = 1;
488 resultStr = factory->NewFromASCII("1e-4");
489 JSHandle<EcmaString> handleEcmaStr2(thread, NumberHelper::DoubleToExponential(thread,
490 0.00011235600000000001, radix));
491 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr2, resultStr), 0);
492
493 radix = 2;
494 resultStr = factory->NewFromASCII("1.1e-4");
495 JSHandle<EcmaString> handleEcmaStr3(thread, NumberHelper::DoubleToExponential(thread,
496 0.00011235600000000001, radix));
497 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr3, resultStr), 0);
498
499 radix = 16;
500 resultStr = factory->NewFromASCII("1.123560000000000e-4");
501 JSHandle<EcmaString> handleEcmaStr4(thread, NumberHelper::DoubleToExponential(thread,
502 0.00011235600000000001, radix));
503 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr4, resultStr), 0);
504
505 radix = 0;
506 resultStr = factory->NewFromASCII("1.23456e+2");
507 JSHandle<EcmaString> handleEcmaStr5(thread, NumberHelper::DoubleToExponential(thread, 123.456, radix));
508 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr5, resultStr), 0);
509
510 radix = 1;
511 resultStr = factory->NewFromASCII("1e+2");
512 JSHandle<EcmaString> handleEcmaStr6(thread, NumberHelper::DoubleToExponential(thread, 123.456, radix));
513 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr6, resultStr), 0);
514
515 radix = 2;
516 resultStr = factory->NewFromASCII("1.2e+2");
517 JSHandle<EcmaString> handleEcmaStr7(thread, NumberHelper::DoubleToExponential(thread, 123.456, radix));
518 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr7, resultStr), 0);
519
520 radix = 16;
521 resultStr = factory->NewFromASCII("1.234560000000000e+2");
522 JSHandle<EcmaString> handleEcmaStr8(thread, NumberHelper::DoubleToExponential(thread, 123.456, radix));
523 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr8, resultStr), 0);
524 }
525
HWTEST_F_L0(NumberHelperTest,DoubleToExponential02)526 HWTEST_F_L0(NumberHelperTest, DoubleToExponential02)
527 {
528 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
529 int radix;
530
531 radix = -4;
532 JSHandle<EcmaString> resultStr = factory->NewFromASCII("1.239876e+2");
533 JSHandle<EcmaString> handleEcmaStr1(thread, NumberHelper::DoubleToExponential(thread, 123.9876, radix));
534 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr1, resultStr), 0);
535
536 radix = -6;
537 resultStr = factory->NewFromASCII("1.239876e+2");
538 JSHandle<EcmaString> handleEcmaStr2(thread, NumberHelper::DoubleToExponential(thread, 123.9876, radix));
539 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr2, resultStr), 0);
540
541 radix = 3;
542 resultStr = factory->NewFromASCII("1.24e+2");
543 JSHandle<EcmaString> handleEcmaStr3(thread, NumberHelper::DoubleToExponential(thread, 123.567, radix));
544 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr3, resultStr), 0);
545
546 radix = 7;
547 resultStr = factory->NewFromASCII("1.234567e+2");
548 JSHandle<EcmaString> handleEcmaStr4(thread, NumberHelper::DoubleToExponential(thread, 123.4567, radix));
549 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr4, resultStr), 0);
550
551 radix = 8;
552 resultStr = factory->NewFromASCII("1.2345670e+2");
553 JSHandle<EcmaString> handleEcmaStr5(thread, NumberHelper::DoubleToExponential(thread, 123.45670, radix));
554 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr5, resultStr), 0);
555
556 radix = 4;
557 resultStr = factory->NewFromASCII("1.230e+2");
558 JSHandle<EcmaString> handleEcmaStr6(thread, NumberHelper::DoubleToExponential(thread, 123.0123, radix));
559 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr6, resultStr), 0);
560 }
561
562 /**
563 * @tc.name: StringToDoubleWithRadix
564 * @tc.desc: Convert double decimal type to Precision type through "DoubleToPrecision" function.If the logarithm
565 * of number based on ten is less than zero and radix Digit is more than zero or it is greater than zero
566 * and radix Digit is less than MAX_EXPONENT_DIGIT call the DoubleToFixed function.other call
567 * DoubleToExponential function.
568 * @tc.type: FUNC
569 * @tc.require:
570 */
HWTEST_F_L0(NumberHelperTest,StringToDoubleWithRadix)571 HWTEST_F_L0(NumberHelperTest, StringToDoubleWithRadix)
572 {
573 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
574 int radix;
575 Span<const uint8_t> sp;
576 CVector<uint8_t> buf;
577 JSHandle<EcmaString> resultStr;
578
579 radix = 3;
580 resultStr = factory->NewFromASCII("-12");
581 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
582 bool negative = false;
583 // 5 = 1 * 3 + 2
584 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), -5);
585
586 radix = 4;
587 resultStr = factory->NewFromASCII("1234567");
588 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
589 negative = false;
590 // 27 = (1 * 4 + 2) * 4 + 3
591 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 27);
592 // string has space
593 resultStr = factory->NewFromASCII(" 12345 ");
594 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
595 negative = false;
596 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 27);
597
598 radix = 16;
599 resultStr = factory->NewFromASCII("0x00ff");
600 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
601 negative = false;
602 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 255);
603
604 resultStr = factory->NewFromASCII("0x0010");
605 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
606 negative = false;
607 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 16);
608
609 resultStr = factory->NewFromASCII("0x1234");
610 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
611 negative = false;
612 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 4660);
613 // string has space
614 resultStr = factory->NewFromASCII(" 0x12 ");
615 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
616 negative = false;
617 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 18);
618
619 resultStr = factory->NewFromASCII("0x1234XX");
620 sp = EcmaStringAccessor(resultStr).ToUtf8Span(thread, buf);
621 negative = false;
622 EXPECT_EQ(NumberHelper::StringToDoubleWithRadix(sp.begin(), sp.end(), radix, &negative).GetDouble(), 4660);
623 }
624
625 /**
626 * @tc.name: IntToString
627 * @tc.desc: Convert integer type to string type through "IntToString" function.
628 * @tc.type: FUNC
629 * @tc.require:
630 */
HWTEST_F_L0(NumberHelperTest,IntToString)631 HWTEST_F_L0(NumberHelperTest, IntToString)
632 {
633 EXPECT_STREQ(NumberHelper::IntToString(0).c_str(), "0");
634 EXPECT_STREQ(NumberHelper::IntToString(-100).c_str(), "-100");
635 EXPECT_STREQ(NumberHelper::IntToString(123).c_str(), "123");
636 EXPECT_STREQ(NumberHelper::IntToString(1234).c_str(), "1234");
637 }
638
639 /**
640 * @tc.name: IntegerToString
641 * @tc.desc: Convert the decimal number into the hexadecimal number corresponding to Radix and convert it into a string
642 * Check whether the returned string result is the same as the actual conversion result.
643 * @tc.type: FUNC
644 * @tc.require:
645 */
HWTEST_F_L0(NumberHelperTest,IntegerToString)646 HWTEST_F_L0(NumberHelperTest, IntegerToString)
647 {
648 int radix = 2;
649 // number = (radix + 1) * MAX_MANTISSA
650 CString integerStr = NumberHelper::IntegerToString(static_cast<double>((radix + 1) * (0x1ULL << 52U)), radix);
651 EXPECT_STREQ(integerStr.c_str(), "110000000000000000000000000000000000000000000000000000");
652
653 integerStr = NumberHelper::IntegerToString(static_cast<double>(10), radix);
654 EXPECT_STREQ(integerStr.c_str(), "1010");
655
656 radix = 3;
657 integerStr = NumberHelper::IntegerToString(static_cast<double>(33), radix);
658 EXPECT_STREQ(integerStr.c_str(), "1020");
659
660 radix = 8;
661 integerStr = NumberHelper::IntegerToString(static_cast<double>(128), radix);
662 EXPECT_STREQ(integerStr.c_str(), "200");
663
664 integerStr = NumberHelper::IntegerToString(static_cast<double>(128.985), radix);
665 EXPECT_STREQ(integerStr.c_str(), "200");
666
667 radix = 16;
668 integerStr = NumberHelper::IntegerToString(static_cast<double>(256), radix);
669 EXPECT_STREQ(integerStr.c_str(), "100");
670
671 radix = 24;
672 integerStr = NumberHelper::IntegerToString(static_cast<double>(987654), radix);
673 EXPECT_STREQ(integerStr.c_str(), "2nag6");
674
675 integerStr = NumberHelper::IntegerToString(static_cast<double>(23), radix);
676 EXPECT_STREQ(integerStr.c_str(), "n");
677 }
678
679 /**
680 * @tc.name: NumberToString
681 * @tc.desc: The abstract operation NumberToString converts a Number m to String format
682 * @tc.type: FUNC
683 * @tc.require:
684 */
HWTEST_F_L0(NumberHelperTest,NumberToString)685 HWTEST_F_L0(NumberHelperTest, NumberToString)
686 {
687 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
688 double d = 8.1999999999999993;
689 JSHandle<EcmaString> result = NumberHelper::NumberToString(thread, JSTaggedValue(d));
690 JSHandle<EcmaString> target = factory->NewFromASCII("8.2");
691 EXPECT_EQ(EcmaStringAccessor::Compare(instance, result, target), 0);
692
693 double d2 = 0.30000000000000004;
694 JSHandle<EcmaString> result1 = NumberHelper::NumberToString(thread, JSTaggedValue(d2));
695 JSHandle<EcmaString> target1 = factory->NewFromASCII("0.30000000000000004");
696 EXPECT_EQ(EcmaStringAccessor::Compare(instance, result1, target1), 0);
697 }
698
699 /**
700 * @tc.name: DoubleToInt64
701 * @tc.desc: The abstract operation DoubleToInt64 converts a double value to int64_t
702 * @tc.type: FUNC
703 * @tc.require:
704 */
HWTEST_F_L0(NumberHelperTest,DoubleToInt64)705 HWTEST_F_L0(NumberHelperTest, DoubleToInt64)
706 {
707 int64_t d = NumberHelper::DoubleToInt64(std::numeric_limits<double>::max());
708 EXPECT_EQ(d, std::numeric_limits<int64_t>::max());
709
710 int64_t d1 = NumberHelper::DoubleToInt64(static_cast<double>(std::numeric_limits<int64_t>::max()));
711 EXPECT_EQ(d1, std::numeric_limits<int64_t>::max());
712 int64_t d2 = NumberHelper::DoubleToInt64(static_cast<double>(std::numeric_limits<int64_t>::min()));
713 EXPECT_EQ(d2, std::numeric_limits<int64_t>::min());
714
715 int64_t d3 = NumberHelper::DoubleToInt64(static_cast<double>(std::numeric_limits<int64_t>::max()) + 1);
716 EXPECT_EQ(d3, std::numeric_limits<int64_t>::max());
717 int64_t d4 = NumberHelper::DoubleToInt64(static_cast<double>(std::numeric_limits<int64_t>::min()) - 1);
718 EXPECT_EQ(d4, std::numeric_limits<int64_t>::min());
719
720 int64_t d5 = NumberHelper::DoubleToInt64(0);
721 EXPECT_EQ(d5, 0);
722 }
723 /**
724 * @tc.name: DoubleToASCII
725 * @tc.desc: When flag is equal to 2, the calculation result of DoubleToASCII is number.toFixed()
726 * @tc.type: FUNC
727 * @tc.require:
728 */
729
HWTEST_F_L0(NumberHelperTest,DoubleToASCII_001)730 HWTEST_F_L0(NumberHelperTest, DoubleToASCII_001)
731 {
732 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
733 int flags = 2;
734 int digit = 2;
735 JSHandle<EcmaString> resultStr = factory->NewFromASCII("0.10");
736 JSHandle<EcmaString> handleEcmaStr(thread, NumberHelper::DoubleToASCII(thread,
737 0.10000000000000001, digit, flags));
738 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr, resultStr), 0);
739
740 digit = 3;
741 resultStr = factory->NewFromASCII("0.100");
742 JSHandle<EcmaString> handleEcmaStr1(thread, NumberHelper::DoubleToASCII(thread,
743 0.10000000000000001, digit, flags));
744 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr1, resultStr), 0);
745
746 digit = 2;
747 resultStr = factory->NewFromASCII("0.01");
748 JSHandle<EcmaString> handleEcmaStr2(thread, NumberHelper::DoubleToASCII(thread,
749 0.01, digit, flags));
750 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr2, resultStr), 0);
751
752 digit = 3;
753 resultStr = factory->NewFromASCII("0.010");
754 JSHandle<EcmaString> handleEcmaStr3(thread, NumberHelper::DoubleToASCII(thread,
755 0.01, digit, flags));
756 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr3, resultStr), 0);
757
758 digit = 7;
759 resultStr = factory->NewFromASCII("0.0000006");
760 JSHandle<EcmaString> handleEcmaStr4(thread, NumberHelper::DoubleToASCII(thread,
761 5.9999999999999997e-07, digit, flags));
762 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr4, resultStr), 0);
763
764 digit = 8;
765 resultStr = factory->NewFromASCII("0.00000006");
766 JSHandle<EcmaString> handleEcmaStr5(thread, NumberHelper::DoubleToASCII(thread,
767 5.9999999999999997e-08, digit, flags));
768 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr5, resultStr), 0);
769
770 digit = 1;
771 #if defined(PANDA_TARGET_ARM32) || defined(RUN_WITH_QEMU)
772 resultStr = factory->NewFromASCII("1.2");
773 #else
774 resultStr = factory->NewFromASCII("1.3");
775 #endif
776 JSHandle<EcmaString> handleEcmaStr6(thread, NumberHelper::DoubleToASCII(thread, 1.25, digit, flags));
777 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr6, resultStr), 0);
778
779 digit = 1;
780 #if defined(PANDA_TARGET_ARM32) || defined(RUN_WITH_QEMU)
781 resultStr = factory->NewFromASCII("-1.2");
782 #else
783 resultStr = factory->NewFromASCII("-1.3");
784 #endif
785 JSHandle<EcmaString> handleEcmaStr7(thread, NumberHelper::DoubleToASCII(thread, -1.25, digit, flags));
786 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr7, resultStr), 0);
787 }
788
789 /**
790 * @tc.name: DoubleToASCII
791 * @tc.desc: When flag is equal to 1, the calculation result of DoubleToASCII is number.toPrecision()
792 * @tc.type: FUNC
793 * @tc.require:
794 */
HWTEST_F_L0(NumberHelperTest,DoubleToASCII_002)795 HWTEST_F_L0(NumberHelperTest, DoubleToASCII_002)
796 {
797 ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
798 int flags = 1;
799 int digit = 2;
800 JSHandle<EcmaString> resultStr = factory->NewFromASCII("-1.2e-9");
801 JSHandle<EcmaString> handleEcmaStr(thread, NumberHelper::DoubleToASCII(thread, -1.2345e-09, digit, flags));
802 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr, resultStr), 0);
803
804 digit = 2;
805 flags = 1;
806 resultStr = factory->NewFromASCII("1.2e-8");
807 JSHandle<EcmaString> handleEcmaStr1(thread, NumberHelper::DoubleToASCII(thread,
808 1.2345000000000001e-08, digit, flags));
809 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr1, resultStr), 0);
810
811 digit = 2;
812 flags = 1;
813 #if defined(PANDA_TARGET_ARM32) || defined(RUN_WITH_QEMU)
814 resultStr = factory->NewFromASCII("1.2");
815 #else
816 resultStr = factory->NewFromASCII("1.3");
817 #endif
818 JSHandle<EcmaString> handleEcmaStr2(thread, NumberHelper::DoubleToASCII(thread, 1.25, digit, flags));
819 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr2, resultStr), 0);
820
821 digit = 2;
822 flags = 1;
823 resultStr = factory->NewFromASCII("1.4");
824 JSHandle<EcmaString> handleEcmaStr3(thread, NumberHelper::DoubleToASCII(thread, 1.35, digit, flags));
825 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr3, resultStr), 0);
826
827
828 digit = 15;
829 flags = 1;
830 resultStr = factory->NewFromASCII("0.000555000000000000");
831 JSHandle<EcmaString> handleEcmaStr4(thread, NumberHelper::DoubleToASCII(thread,
832 0.00055500000000000005, digit, flags));
833 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr4, resultStr), 0);
834
835 digit = 15;
836 flags = 1;
837 resultStr = factory->NewFromASCII("5.55000000000000e-7");
838 JSHandle<EcmaString> handleEcmaStr5(thread, NumberHelper::DoubleToASCII(thread,
839 5.5499999999999998e-07, digit, flags));
840 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr5, resultStr), 0);
841
842 digit = 15;
843 flags = 1;
844 resultStr = factory->NewFromASCII("-5.55000000000000e-7");
845 JSHandle<EcmaString> handleEcmaStr6(thread, NumberHelper::DoubleToASCII(thread,
846 -5.5499999999999998e-07, digit, flags));
847 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr6, resultStr), 0);
848
849 digit = 2;
850 flags = 1;
851 resultStr = factory->NewFromASCII("-12");
852 JSHandle<EcmaString> handleEcmaStr7(thread, NumberHelper::DoubleToASCII(thread,
853 -12.345000000000001, digit, flags));
854 EXPECT_EQ(EcmaStringAccessor::Compare(instance, handleEcmaStr7, resultStr), 0);
855 }
856
HWTEST_F_L0(NumberHelperTest,FastStringToInt)857 HWTEST_F_L0(NumberHelperTest, FastStringToInt)
858 {
859 std::vector<std::vector<std::string_view>> inputs = {
860 {"1", "3", "9", "8", "6", "4", "2", "5", "7", "0"},
861 {"14", "39", "78", "21", "53", "86", "95", "62", "47", "18"},
862 {"294", "185", "762", "439", "816", "931", "728", "657", "328", "149"},
863 {"1837", "2495", "3926", "7812", "9365", "5748", "8129", "6723", "4531", "3184"},
864 {"18374", "29583", "71426", "98432", "57613", "83625", "49216", "63841", "73198", "15892"},
865 {"918374", "738152", "184729", "627391", "495681", "352716", "816429", "274839", "639182", "517392"},
866 {"1983741", "6273918", "5839162", "9127384", "3728195", "6938271", "8491326", "7153962", "2839173", "1982735"},
867 {"91837462", "73815294", "18472951", "62739185", "49568124", "35271639", "81642975", "27483916", "63918257",
868 "51739268"},
869 {"4294967295"}
870 };
871 std::vector<std::vector<uint32_t>> expected = {
872 {1, 3, 9, 8, 6, 4, 2, 5, 7, 0},
873 {14, 39, 78, 21, 53, 86, 95, 62, 47, 18},
874 {294, 185, 762, 439, 816, 931, 728, 657, 328, 149},
875 {1837, 2495, 3926, 7812, 9365, 5748, 8129, 6723, 4531, 3184},
876 {18374, 29583, 71426, 98432, 57613, 83625, 49216, 63841, 73198, 15892},
877 {918374, 738152, 184729, 627391, 495681, 352716, 816429, 274839, 639182, 517392},
878 {1983741, 6273918, 5839162, 9127384, 3728195, 6938271, 8491326, 7153962, 2839173, 1982735},
879 {91837462, 73815294, 18472951, 62739185, 49568124, 35271639, 81642975, 27483916, 63918257, 51739268},
880 {4294967295}
881 };
882
883 for (std::size_t i = 0; i < inputs.size(); ++i) {
884 const std::vector<std::string_view>& group = inputs[i];
885 for (std::size_t j = 0; j < group.size(); ++j) {
886 uint32_t result;
887 NumberHelper::StringToUint<uint32_t, char>(group[j], result, std::numeric_limits<uint32_t>::max());
888 EXPECT_EQ(result, expected[i][j]);
889 }
890 }
891 }
892
HWTEST_F_L0(NumberHelperTest,FastStringToIntFail)893 HWTEST_F_L0(NumberHelperTest, FastStringToIntFail)
894 {
895 std::vector<std::string_view> inputs = {
896 "-1", ".3", "09", "8x", "0x6", "c4", "2十一", "0.5", "7.0", "-0", "14000000000", "9000000000", "4294967296"
897 };
898
899 for (auto input : inputs) {
900 uint32_t result;
901 bool success = NumberHelper::StringToUint<uint32_t, char>(input, result, std::numeric_limits<uint32_t>::max());
902 EXPECT_FALSE(success);
903 }
904 }
905
HWTEST_F_L0(NumberHelperTest,FastStringToNumberForLineString)906 HWTEST_F_L0(NumberHelperTest, FastStringToNumberForLineString)
907 {
908 std::vector<std::string> inputs = {
909 "0", "1", "26", "371", "4592", "53100", "642197", "7126573", "81230248", "912331534",
910 "-12", "-345", "-4578", "-135936383", "1.0", "3.21", "54.98", "abcd", "qwerty", "3.123ab"
911 };
912 std::vector<bool> expectedIsSuccess = {
913 true, true, true, true, true, true, true, true, true, true,
914 true, true, true, true, false, false, false, true, true, false
915 };
916 std::vector<uint32_t> expectedValue = {
917 0, 1, 26, 371, 4592, 53100, 642197, 7126573, 81230248, 912331534,
918 -12, -345, -4578, -135936383, 0, 0, 0, 0, 0, 0,
919 };
920 for (std::size_t i = 0; i < inputs.size(); ++i) {
921 Span<const uint8_t> str = Span(reinterpret_cast<const uint8_t *>(inputs[i].data()), inputs[i].length());
922 auto ecmaString = EcmaStringAccessor::CreateFromUtf8(instance, str.data(), str.size(), true);
923 auto baseString = ecmaString->ToBaseString();
924 baseString->SetIsInternString();
925 common::IntegerCache::InitIntegerCache(baseString);
926 common::IntegerCache *cache = nullptr;
927 if (baseString->GetLength() <= common::IntegerCache::MAX_INTEGER_CACHE_SIZE) {
928 cache = common::IntegerCache::Extract(ecmaString->ToBaseString());
929 }
930 auto resCached = NumberHelper::FastStringToNumber(str.begin(), str.end(), cache);
931 ASSERT_EQ(resCached.first, expectedIsSuccess[i]);
932 ASSERT_EQ(resCached.second.ToInt32(), expectedValue[i]);
933 }
934 }
935 } // namespace panda::ecmascript
936