1 /*
2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 // This file is available under and governed by the GNU General Public
27 // License version 2 only, as published by the Free Software Foundation.
28 // However, the following notice accompanied the original version of this
29 // file:
30 //
31 // Copyright 2010 the V8 project authors. All rights reserved.
32 // Redistribution and use in source and binary forms, with or without
33 // modification, are permitted provided that the following conditions are
34 // met:
35 //
36 // * Redistributions of source code must retain the above copyright
37 // notice, this list of conditions and the following disclaimer.
38 // * Redistributions in binary form must reproduce the above
39 // copyright notice, this list of conditions and the following
40 // disclaimer in the documentation and/or other materials provided
41 // with the distribution.
42 // * Neither the name of Google Inc. nor the names of its
43 // contributors may be used to endorse or promote products derived
44 // from this software without specific prior written permission.
45 //
46 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
47 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
48 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
49 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
50 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
51 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
52 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
56 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57
58 package jdk.nashorn.internal.runtime.doubleconv.test;
59
60 import java.io.BufferedReader;
61 import java.io.InputStreamReader;
62 import java.util.concurrent.atomic.AtomicInteger;
63 import jdk.nashorn.internal.runtime.doubleconv.DoubleConversion;
64 import jdk.nashorn.internal.runtime.doubleconv.DtoaBuffer;
65
66 import org.testng.annotations.Test;
67
68 import static org.testng.Assert.assertEquals;
69 import static org.testng.Assert.assertTrue;
70
71 /**
72 * FixedDtoa tests
73 */
74 @SuppressWarnings("javadoc")
75 public class FixedDtoaTest {
76
77 static final int kBufferSize = 500;
78
79 @Test
80 public void testFastShortestVarious() {
81 final DtoaBuffer buffer = new DtoaBuffer(kBufferSize);
82
83 assertTrue(DoubleConversion.fixedDtoa(1.0, 1, buffer));
84 assertEquals("1", buffer.getRawDigits());
85 assertEquals(1, buffer.getDecimalPoint());
86 buffer.reset();
87
88 assertTrue(DoubleConversion.fixedDtoa(1.0, 15, buffer));
89 assertEquals("1", buffer.getRawDigits());
90 assertEquals(1, buffer.getDecimalPoint());
91 buffer.reset();
92
93 assertTrue(DoubleConversion.fixedDtoa(1.0, 0, buffer));
94 assertEquals("1", buffer.getRawDigits());
95 assertEquals(1, buffer.getDecimalPoint());
96 buffer.reset();
97
98 assertTrue(DoubleConversion.fixedDtoa(0xFFFFFFFFL, 5, buffer));
99 assertEquals("4294967295", buffer.getRawDigits());
100 assertEquals(10, buffer.getDecimalPoint());
101 buffer.reset();
102
103 assertTrue(DoubleConversion.fixedDtoa(4294967296.0, 5, buffer));
104 assertEquals("4294967296", buffer.getRawDigits());
105 assertEquals(10, buffer.getDecimalPoint());
106 buffer.reset();
107
108 assertTrue(DoubleConversion.fixedDtoa(1e21, 5, buffer));
109 assertEquals("1", buffer.getRawDigits());
110 assertEquals(22, buffer.getDecimalPoint());
111 buffer.reset();
112
113 assertTrue(DoubleConversion.fixedDtoa(999999999999999868928.00, 2, buffer));
114 assertEquals("999999999999999868928", buffer.getRawDigits());
115 assertEquals(21, buffer.getDecimalPoint());
116 buffer.reset();
117
118 assertTrue(DoubleConversion.fixedDtoa(6.9999999999999989514240000e+21, 5, buffer));
119 assertEquals("6999999999999998951424", buffer.getRawDigits());
120 assertEquals(22, buffer.getDecimalPoint());
121 buffer.reset();
122
123 assertTrue(DoubleConversion.fixedDtoa(1.5, 5, buffer));
124 assertEquals("15", buffer.getRawDigits());
125 assertEquals(1, buffer.getDecimalPoint());
126 buffer.reset();
127
128 assertTrue(DoubleConversion.fixedDtoa(1.55, 5, buffer));
129 assertEquals("155", buffer.getRawDigits());
130 assertEquals(1, buffer.getDecimalPoint());
131 buffer.reset();
132
133 assertTrue(DoubleConversion.fixedDtoa(1.55, 1, buffer));
134 assertEquals("16", buffer.getRawDigits());
135 assertEquals(1, buffer.getDecimalPoint());
136 buffer.reset();
137
138 assertTrue(DoubleConversion.fixedDtoa(1.00000001, 15, buffer));
139 assertEquals("100000001", buffer.getRawDigits());
140 assertEquals(1, buffer.getDecimalPoint());
141 buffer.reset();
142
143 assertTrue(DoubleConversion.fixedDtoa(0.1, 10, buffer));
144 assertEquals("1", buffer.getRawDigits());
145 assertEquals(0, buffer.getDecimalPoint());
146 buffer.reset();
147
148 assertTrue(DoubleConversion.fixedDtoa(0.01, 10, buffer));
149 assertEquals("1", buffer.getRawDigits());
150 assertEquals(-1, buffer.getDecimalPoint());
151 buffer.reset();
152
153 assertTrue(DoubleConversion.fixedDtoa(0.001, 10, buffer));
154 assertEquals("1", buffer.getRawDigits());
155 assertEquals(-2, buffer.getDecimalPoint());
156 buffer.reset();
157
158 assertTrue(DoubleConversion.fixedDtoa(0.0001, 10, buffer));
159 assertEquals("1", buffer.getRawDigits());
160 assertEquals(-3, buffer.getDecimalPoint());
161 buffer.reset();
162
163 assertTrue(DoubleConversion.fixedDtoa(0.00001, 10, buffer));
164 assertEquals("1", buffer.getRawDigits());
165 assertEquals(-4, buffer.getDecimalPoint());
166 buffer.reset();
167
168 assertTrue(DoubleConversion.fixedDtoa(0.000001, 10, buffer));
169 assertEquals("1", buffer.getRawDigits());
170 assertEquals(-5, buffer.getDecimalPoint());
171 buffer.reset();
172
173 assertTrue(DoubleConversion.fixedDtoa(0.0000001, 10, buffer));
174 assertEquals("1", buffer.getRawDigits());
175 assertEquals(-6, buffer.getDecimalPoint());
176 buffer.reset();
177
178 assertTrue(DoubleConversion.fixedDtoa(0.00000001, 10, buffer));
179 assertEquals("1", buffer.getRawDigits());
180 assertEquals(-7, buffer.getDecimalPoint());
181 buffer.reset();
182
183 assertTrue(DoubleConversion.fixedDtoa(0.000000001, 10, buffer));
184 assertEquals("1", buffer.getRawDigits());
185 assertEquals(-8, buffer.getDecimalPoint());
186 buffer.reset();
187
188 assertTrue(DoubleConversion.fixedDtoa(0.0000000001, 15, buffer));
189 assertEquals("1", buffer.getRawDigits());
190 assertEquals(-9, buffer.getDecimalPoint());
191 buffer.reset();
192
193 assertTrue(DoubleConversion.fixedDtoa(0.00000000001, 15, buffer));
194 assertEquals("1", buffer.getRawDigits());
195 assertEquals(-10, buffer.getDecimalPoint());
196 buffer.reset();
197
198 assertTrue(DoubleConversion.fixedDtoa(0.000000000001, 15, buffer));
199 assertEquals("1", buffer.getRawDigits());
200 assertEquals(-11, buffer.getDecimalPoint());
201 buffer.reset();
202
203 assertTrue(DoubleConversion.fixedDtoa(0.0000000000001, 15, buffer));
204 assertEquals("1", buffer.getRawDigits());
205 assertEquals(-12, buffer.getDecimalPoint());
206 buffer.reset();
207
208 assertTrue(DoubleConversion.fixedDtoa(0.00000000000001, 15, buffer));
209 assertEquals("1", buffer.getRawDigits());
210 assertEquals(-13, buffer.getDecimalPoint());
211 buffer.reset();
212
213 assertTrue(DoubleConversion.fixedDtoa(0.000000000000001, 20, buffer));
214 assertEquals("1", buffer.getRawDigits());
215 assertEquals(-14, buffer.getDecimalPoint());
216 buffer.reset();
217
218 assertTrue(DoubleConversion.fixedDtoa(0.0000000000000001, 20, buffer));
219 assertEquals("1", buffer.getRawDigits());
220 assertEquals(-15, buffer.getDecimalPoint());
221 buffer.reset();
222
223 assertTrue(DoubleConversion.fixedDtoa(0.00000000000000001, 20, buffer));
224 assertEquals("1", buffer.getRawDigits());
225 assertEquals(-16, buffer.getDecimalPoint());
226 buffer.reset();
227
228 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000001, 20, buffer));
229 assertEquals("1", buffer.getRawDigits());
230 assertEquals(-17, buffer.getDecimalPoint());
231 buffer.reset();
232
233 assertTrue(DoubleConversion.fixedDtoa(0.0000000000000000001, 20, buffer));
234 assertEquals("1", buffer.getRawDigits());
235 assertEquals(-18, buffer.getDecimalPoint());
236 buffer.reset();
237
238 assertTrue(DoubleConversion.fixedDtoa(0.00000000000000000001, 20, buffer));
239 assertEquals("1", buffer.getRawDigits());
240 assertEquals(-19, buffer.getDecimalPoint());
241 buffer.reset();
242
243 assertTrue(DoubleConversion.fixedDtoa(0.10000000004, 10, buffer));
244 assertEquals("1", buffer.getRawDigits());
245 assertEquals(0, buffer.getDecimalPoint());
246 buffer.reset();
247
248 assertTrue(DoubleConversion.fixedDtoa(0.01000000004, 10, buffer));
249 assertEquals("1", buffer.getRawDigits());
250 assertEquals(-1, buffer.getDecimalPoint());
251 buffer.reset();
252
253 assertTrue(DoubleConversion.fixedDtoa(0.00100000004, 10, buffer));
254 assertEquals("1", buffer.getRawDigits());
255 assertEquals(-2, buffer.getDecimalPoint());
256 buffer.reset();
257
258 assertTrue(DoubleConversion.fixedDtoa(0.00010000004, 10, buffer));
259 assertEquals("1", buffer.getRawDigits());
260 assertEquals(-3, buffer.getDecimalPoint());
261 buffer.reset();
262
263 assertTrue(DoubleConversion.fixedDtoa(0.00001000004, 10, buffer));
264 assertEquals("1", buffer.getRawDigits());
265 assertEquals(-4, buffer.getDecimalPoint());
266 buffer.reset();
267
268 assertTrue(DoubleConversion.fixedDtoa(0.00000100004, 10, buffer));
269 assertEquals("1", buffer.getRawDigits());
270 assertEquals(-5, buffer.getDecimalPoint());
271 buffer.reset();
272
273 assertTrue(DoubleConversion.fixedDtoa(0.00000010004, 10, buffer));
274 assertEquals("1", buffer.getRawDigits());
275 assertEquals(-6, buffer.getDecimalPoint());
276 buffer.reset();
277
278 assertTrue(DoubleConversion.fixedDtoa(0.00000001004, 10, buffer));
279 assertEquals("1", buffer.getRawDigits());
280 assertEquals(-7, buffer.getDecimalPoint());
281 buffer.reset();
282
283 assertTrue(DoubleConversion.fixedDtoa(0.00000000104, 10, buffer));
284 assertEquals("1", buffer.getRawDigits());
285 assertEquals(-8, buffer.getDecimalPoint());
286 buffer.reset();
287
288 assertTrue(DoubleConversion.fixedDtoa(0.0000000001000004, 15, buffer));
289 assertEquals("1", buffer.getRawDigits());
290 assertEquals(-9, buffer.getDecimalPoint());
291 buffer.reset();
292
293 assertTrue(DoubleConversion.fixedDtoa(0.0000000000100004, 15, buffer));
294 assertEquals("1", buffer.getRawDigits());
295 assertEquals(-10, buffer.getDecimalPoint());
296 buffer.reset();
297
298 assertTrue(DoubleConversion.fixedDtoa(0.0000000000010004, 15, buffer));
299 assertEquals("1", buffer.getRawDigits());
300 assertEquals(-11, buffer.getDecimalPoint());
301 buffer.reset();
302
303 assertTrue(DoubleConversion.fixedDtoa(0.0000000000001004, 15, buffer));
304 assertEquals("1", buffer.getRawDigits());
305 assertEquals(-12, buffer.getDecimalPoint());
306 buffer.reset();
307
308 assertTrue(DoubleConversion.fixedDtoa(0.0000000000000104, 15, buffer));
309 assertEquals("1", buffer.getRawDigits());
310 assertEquals(-13, buffer.getDecimalPoint());
311 buffer.reset();
312
313 assertTrue(DoubleConversion.fixedDtoa(0.000000000000001000004, 20, buffer));
314 assertEquals("1", buffer.getRawDigits());
315 assertEquals(-14, buffer.getDecimalPoint());
316 buffer.reset();
317
318 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000100004, 20, buffer));
319 assertEquals("1", buffer.getRawDigits());
320 assertEquals(-15, buffer.getDecimalPoint());
321 buffer.reset();
322
323 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000010004, 20, buffer));
324 assertEquals("1", buffer.getRawDigits());
325 assertEquals(-16, buffer.getDecimalPoint());
326 buffer.reset();
327
328 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000001004, 20, buffer));
329 assertEquals("1", buffer.getRawDigits());
330 assertEquals(-17, buffer.getDecimalPoint());
331 buffer.reset();
332
333 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000104, 20, buffer));
334 assertEquals("1", buffer.getRawDigits());
335 assertEquals(-18, buffer.getDecimalPoint());
336 buffer.reset();
337
338 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000014, 20, buffer));
339 assertEquals("1", buffer.getRawDigits());
340 assertEquals(-19, buffer.getDecimalPoint());
341 buffer.reset();
342
343 assertTrue(DoubleConversion.fixedDtoa(0.10000000006, 10, buffer));
344 assertEquals("1000000001", buffer.getRawDigits());
345 assertEquals(0, buffer.getDecimalPoint());
346 buffer.reset();
347
348 assertTrue(DoubleConversion.fixedDtoa(0.01000000006, 10, buffer));
349 assertEquals("100000001", buffer.getRawDigits());
350 assertEquals(-1, buffer.getDecimalPoint());
351 buffer.reset();
352
353 assertTrue(DoubleConversion.fixedDtoa(0.00100000006, 10, buffer));
354 assertEquals("10000001", buffer.getRawDigits());
355 assertEquals(-2, buffer.getDecimalPoint());
356 buffer.reset();
357
358 assertTrue(DoubleConversion.fixedDtoa(0.00010000006, 10, buffer));
359 assertEquals("1000001", buffer.getRawDigits());
360 assertEquals(-3, buffer.getDecimalPoint());
361 buffer.reset();
362
363 assertTrue(DoubleConversion.fixedDtoa(0.00001000006, 10, buffer));
364 assertEquals("100001", buffer.getRawDigits());
365 assertEquals(-4, buffer.getDecimalPoint());
366 buffer.reset();
367
368 assertTrue(DoubleConversion.fixedDtoa(0.00000100006, 10, buffer));
369 assertEquals("10001", buffer.getRawDigits());
370 assertEquals(-5, buffer.getDecimalPoint());
371 buffer.reset();
372
373 assertTrue(DoubleConversion.fixedDtoa(0.00000010006, 10, buffer));
374 assertEquals("1001", buffer.getRawDigits());
375 assertEquals(-6, buffer.getDecimalPoint());
376 buffer.reset();
377
378 assertTrue(DoubleConversion.fixedDtoa(0.00000001006, 10, buffer));
379 assertEquals("101", buffer.getRawDigits());
380 assertEquals(-7, buffer.getDecimalPoint());
381 buffer.reset();
382
383 assertTrue(DoubleConversion.fixedDtoa(0.00000000106, 10, buffer));
384 assertEquals("11", buffer.getRawDigits());
385 assertEquals(-8, buffer.getDecimalPoint());
386 buffer.reset();
387
388 assertTrue(DoubleConversion.fixedDtoa(0.0000000001000006, 15, buffer));
389 assertEquals("100001", buffer.getRawDigits());
390 assertEquals(-9, buffer.getDecimalPoint());
391 buffer.reset();
392
393 assertTrue(DoubleConversion.fixedDtoa(0.0000000000100006, 15, buffer));
394 assertEquals("10001", buffer.getRawDigits());
395 assertEquals(-10, buffer.getDecimalPoint());
396 buffer.reset();
397
398 assertTrue(DoubleConversion.fixedDtoa(0.0000000000010006, 15, buffer));
399 assertEquals("1001", buffer.getRawDigits());
400 assertEquals(-11, buffer.getDecimalPoint());
401 buffer.reset();
402
403 assertTrue(DoubleConversion.fixedDtoa(0.0000000000001006, 15, buffer));
404 assertEquals("101", buffer.getRawDigits());
405 assertEquals(-12, buffer.getDecimalPoint());
406 buffer.reset();
407
408 assertTrue(DoubleConversion.fixedDtoa(0.0000000000000106, 15, buffer));
409 assertEquals("11", buffer.getRawDigits());
410 assertEquals(-13, buffer.getDecimalPoint());
411 buffer.reset();
412
413 assertTrue(DoubleConversion.fixedDtoa(0.000000000000001000006, 20, buffer));
414 assertEquals("100001", buffer.getRawDigits());
415 assertEquals(-14, buffer.getDecimalPoint());
416 buffer.reset();
417
418 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000100006, 20, buffer));
419 assertEquals("10001", buffer.getRawDigits());
420 assertEquals(-15, buffer.getDecimalPoint());
421 buffer.reset();
422
423 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000010006, 20, buffer));
424 assertEquals("1001", buffer.getRawDigits());
425 assertEquals(-16, buffer.getDecimalPoint());
426 buffer.reset();
427
428 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000001006, 20, buffer));
429 assertEquals("101", buffer.getRawDigits());
430 assertEquals(-17, buffer.getDecimalPoint());
431 buffer.reset();
432
433 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000106, 20, buffer));
434 assertEquals("11", buffer.getRawDigits());
435 assertEquals(-18, buffer.getDecimalPoint());
436 buffer.reset();
437
438 assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000016, 20, buffer));
439 assertEquals("2", buffer.getRawDigits());
440 assertEquals(-19, buffer.getDecimalPoint());
441 buffer.reset();
442
443 assertTrue(DoubleConversion.fixedDtoa(0.6, 0, buffer));
444 assertEquals("1", buffer.getRawDigits());
445 assertEquals(1, buffer.getDecimalPoint());
446 buffer.reset();
447
448 assertTrue(DoubleConversion.fixedDtoa(0.96, 1, buffer));
449 assertEquals("1", buffer.getRawDigits());
450 assertEquals(1, buffer.getDecimalPoint());
451 buffer.reset();
452
453 assertTrue(DoubleConversion.fixedDtoa(0.996, 2, buffer));
454 assertEquals("1", buffer.getRawDigits());
455 assertEquals(1, buffer.getDecimalPoint());
456 buffer.reset();
457
458 assertTrue(DoubleConversion.fixedDtoa(0.9996, 3, buffer));
459 assertEquals("1", buffer.getRawDigits());
460 assertEquals(1, buffer.getDecimalPoint());
461 buffer.reset();
462
463 assertTrue(DoubleConversion.fixedDtoa(0.99996, 4, buffer));
464 assertEquals("1", buffer.getRawDigits());
465 assertEquals(1, buffer.getDecimalPoint());
466 buffer.reset();
467
468 assertTrue(DoubleConversion.fixedDtoa(0.999996, 5, buffer));
469 assertEquals("1", buffer.getRawDigits());
470 assertEquals(1, buffer.getDecimalPoint());
471 buffer.reset();
472
473 assertTrue(DoubleConversion.fixedDtoa(0.9999996, 6, buffer));
474 assertEquals("1", buffer.getRawDigits());
475 assertEquals(1, buffer.getDecimalPoint());
476 buffer.reset();
477
478 assertTrue(DoubleConversion.fixedDtoa(0.99999996, 7, buffer));
479 assertEquals("1", buffer.getRawDigits());
480 assertEquals(1, buffer.getDecimalPoint());
481 buffer.reset();
482
483 assertTrue(DoubleConversion.fixedDtoa(0.999999996, 8, buffer));
484 assertEquals("1", buffer.getRawDigits());
485 assertEquals(1, buffer.getDecimalPoint());
486 buffer.reset();
487
488 assertTrue(DoubleConversion.fixedDtoa(0.9999999996, 9, buffer));
489 assertEquals("1", buffer.getRawDigits());
490 assertEquals(1, buffer.getDecimalPoint());
491 buffer.reset();
492
493 assertTrue(DoubleConversion.fixedDtoa(0.99999999996, 10, buffer));
494 assertEquals("1", buffer.getRawDigits());
495 assertEquals(1, buffer.getDecimalPoint());
496 buffer.reset();
497
498 assertTrue(DoubleConversion.fixedDtoa(0.999999999996, 11, buffer));
499 assertEquals("1", buffer.getRawDigits());
500 assertEquals(1, buffer.getDecimalPoint());
501 buffer.reset();
502
503 assertTrue(DoubleConversion.fixedDtoa(0.9999999999996, 12, buffer));
504 assertEquals("1", buffer.getRawDigits());
505 assertEquals(1, buffer.getDecimalPoint());
506 buffer.reset();
507
508 assertTrue(DoubleConversion.fixedDtoa(0.99999999999996, 13, buffer));
509 assertEquals("1", buffer.getRawDigits());
510 assertEquals(1, buffer.getDecimalPoint());
511 buffer.reset();
512
513 assertTrue(DoubleConversion.fixedDtoa(0.999999999999996, 14, buffer));
514 assertEquals("1", buffer.getRawDigits());
515 assertEquals(1, buffer.getDecimalPoint());
516 buffer.reset();
517
518 assertTrue(DoubleConversion.fixedDtoa(0.9999999999999996, 15, buffer));
519 assertEquals("1", buffer.getRawDigits());
520 assertEquals(1, buffer.getDecimalPoint());
521 buffer.reset();
522
523 assertTrue(DoubleConversion.fixedDtoa(0.00999999999999996, 16, buffer));
524 assertEquals("1", buffer.getRawDigits());
525 assertEquals(-1, buffer.getDecimalPoint());
526 buffer.reset();
527
528 assertTrue(DoubleConversion.fixedDtoa(0.000999999999999996, 17, buffer));
529 assertEquals("1", buffer.getRawDigits());
530 assertEquals(-2, buffer.getDecimalPoint());
531 buffer.reset();
532
533 assertTrue(DoubleConversion.fixedDtoa(0.0000999999999999996, 18, buffer));
534 assertEquals("1", buffer.getRawDigits());
535 assertEquals(-3, buffer.getDecimalPoint());
536 buffer.reset();
537
538 assertTrue(DoubleConversion.fixedDtoa(0.00000999999999999996, 19, buffer));
539 assertEquals("1", buffer.getRawDigits());
540 assertEquals(-4, buffer.getDecimalPoint());
541 buffer.reset();
542
543 assertTrue(DoubleConversion.fixedDtoa(0.000000999999999999996, 20, buffer));
544 assertEquals("1", buffer.getRawDigits());
545 assertEquals(-5, buffer.getDecimalPoint());
546 buffer.reset();
547
548 assertTrue(DoubleConversion.fixedDtoa(323423.234234, 10, buffer));
549 assertEquals("323423234234", buffer.getRawDigits());
550 assertEquals(6, buffer.getDecimalPoint());
551 buffer.reset();
552
553 assertTrue(DoubleConversion.fixedDtoa(12345678.901234, 4, buffer));
554 assertEquals("123456789012", buffer.getRawDigits());
555 assertEquals(8, buffer.getDecimalPoint());
556 buffer.reset();
557
558 assertTrue(DoubleConversion.fixedDtoa(98765.432109, 5, buffer));
559 assertEquals("9876543211", buffer.getRawDigits());
560 assertEquals(5, buffer.getDecimalPoint());
561 buffer.reset();
562
563 assertTrue(DoubleConversion.fixedDtoa(42, 20, buffer));
564 assertEquals("42", buffer.getRawDigits());
565 assertEquals(2, buffer.getDecimalPoint());
566 buffer.reset();
567
568 assertTrue(DoubleConversion.fixedDtoa(0.5, 0, buffer));
569 assertEquals("1", buffer.getRawDigits());
570 assertEquals(1, buffer.getDecimalPoint());
571 buffer.reset();
572
573 assertTrue(DoubleConversion.fixedDtoa(1e-23, 10, buffer));
574 assertEquals("", buffer.getRawDigits());
575 assertEquals(-10, buffer.getDecimalPoint());
576 buffer.reset();
577
578 assertTrue(DoubleConversion.fixedDtoa(1e-123, 2, buffer));
579 assertEquals("", buffer.getRawDigits());
580 assertEquals(-2, buffer.getDecimalPoint());
581 buffer.reset();
582
583 assertTrue(DoubleConversion.fixedDtoa(1e-123, 0, buffer));
584 assertEquals("", buffer.getRawDigits());
585 assertEquals(0, buffer.getDecimalPoint());
586 buffer.reset();
587
588 assertTrue(DoubleConversion.fixedDtoa(1e-23, 20, buffer));
589 assertEquals("", buffer.getRawDigits());
590 assertEquals(-20, buffer.getDecimalPoint());
591 buffer.reset();
592
593 assertTrue(DoubleConversion.fixedDtoa(1e-21, 20, buffer));
594 assertEquals("", buffer.getRawDigits());
595 assertEquals(-20, buffer.getDecimalPoint());
596 buffer.reset();
597
598 assertTrue(DoubleConversion.fixedDtoa(1e-22, 20, buffer));
599 assertEquals("", buffer.getRawDigits());
600 assertEquals(-20, buffer.getDecimalPoint());
601 buffer.reset();
602
603 assertTrue(DoubleConversion.fixedDtoa(6e-21, 20, buffer));
604 assertEquals("1", buffer.getRawDigits());
605 assertEquals(-19, buffer.getDecimalPoint());
606 buffer.reset();
607
608 assertTrue(DoubleConversion.fixedDtoa(9.1193616301674545152000000e+19, 0, buffer));
609 assertEquals("91193616301674545152", buffer.getRawDigits());
610 assertEquals(20, buffer.getDecimalPoint());
611 buffer.reset();
612
613 assertTrue(DoubleConversion.fixedDtoa(4.8184662102767651659096515e-04, 19, buffer));
614 assertEquals("4818466210276765", buffer.getRawDigits());
615 assertEquals(-3, buffer.getDecimalPoint());
616 buffer.reset();
617
618 assertTrue(DoubleConversion.fixedDtoa(1.9023164229540652612705182e-23, 8, buffer));
619 assertEquals("", buffer.getRawDigits());
620 assertEquals(-8, buffer.getDecimalPoint());
621 buffer.reset();
622
623 assertTrue(DoubleConversion.fixedDtoa(1000000000000000128.0, 0, buffer));
624 assertEquals("1000000000000000128", buffer.getRawDigits());
625 assertEquals(19, buffer.getDecimalPoint());
626 buffer.reset();
627
628 assertTrue(DoubleConversion.fixedDtoa(2.10861548515811875e+15, 17, buffer));
629 assertEquals("210861548515811875", buffer.getRawDigits());
630 assertEquals(16, buffer.getDecimalPoint());
631 buffer.reset();
632 }
633
634
635
636 @Test
637 public void testFastFixed() {
638 final AtomicInteger total = new AtomicInteger();
639 final AtomicInteger succeeded = new AtomicInteger();
640
641 new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("resources/gay-fixed.txt")))
642 .lines()
643 .forEach(line -> {
644 if (line.isEmpty() || line.startsWith("//")) {
645 return; // comment or empty line
646 }
647 final String[] tokens = line.split(",\\s+");
648 assertEquals(tokens.length, 4);
649 final double v = Double.parseDouble(tokens[0]);
650 final int digits = Integer.parseInt(tokens[1]);
651 final String str = tokens[2].replace('"', ' ').trim();;
652 final int point = Integer.parseInt(tokens[3]);
653 final DtoaBuffer buffer = new DtoaBuffer(kBufferSize);
654 total.getAndIncrement();
655
656 if (DoubleConversion.fixedDtoa(v, digits, buffer)) {
657 assertEquals(str, buffer.getRawDigits());
658 assertEquals(point, buffer.getDecimalPoint());
659 succeeded.getAndIncrement();
660 }
661 });
662
663 // should work for all numbers
664 assertEquals(succeeded.get(), total.get());
665 }
666
667 }