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
testFastShortestVarious()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
testFastFixed()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 }
668