FixedDtoaTest.java revision 1507:549f06563f1c 
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
58package jdk.nashorn.internal.runtime.doubleconv.test;
59
60import java.io.BufferedReader;
61import java.io.InputStreamReader;
62import java.util.concurrent.atomic.AtomicInteger;
63import jdk.nashorn.internal.runtime.doubleconv.DoubleConversion;
64import jdk.nashorn.internal.runtime.doubleconv.DtoaBuffer;
65
66import org.testng.annotations.Test;
67
68import static org.testng.Assert.assertEquals;
69import static org.testng.Assert.assertTrue;
70
71/**
72 * FixedDtoa tests
73 *
74 * @test
75 * @run testng jdk.nashorn.internal.runtime.doubleconv.test.FixedDtoaTest
76 */
77@SuppressWarnings("javadoc")
78public class FixedDtoaTest {
79
80    static final int kBufferSize = 500;
81
82    @Test
83    public void testFastShortestVarious() {
84        final DtoaBuffer buffer = new DtoaBuffer(kBufferSize);
85
86        assertTrue(DoubleConversion.fixedDtoa(1.0, 1, buffer));
87        assertEquals("1", buffer.getRawDigits());
88        assertEquals(1, buffer.getDecimalPoint());
89        buffer.reset();
90
91        assertTrue(DoubleConversion.fixedDtoa(1.0, 15, buffer));
92        assertEquals("1", buffer.getRawDigits());
93        assertEquals(1, buffer.getDecimalPoint());
94        buffer.reset();
95
96        assertTrue(DoubleConversion.fixedDtoa(1.0, 0, buffer));
97        assertEquals("1", buffer.getRawDigits());
98        assertEquals(1, buffer.getDecimalPoint());
99        buffer.reset();
100
101        assertTrue(DoubleConversion.fixedDtoa(0xFFFFFFFFL, 5, buffer));
102        assertEquals("4294967295", buffer.getRawDigits());
103        assertEquals(10, buffer.getDecimalPoint());
104        buffer.reset();
105
106        assertTrue(DoubleConversion.fixedDtoa(4294967296.0, 5, buffer));
107        assertEquals("4294967296", buffer.getRawDigits());
108        assertEquals(10, buffer.getDecimalPoint());
109        buffer.reset();
110
111        assertTrue(DoubleConversion.fixedDtoa(1e21, 5, buffer));
112        assertEquals("1", buffer.getRawDigits());
113        assertEquals(22, buffer.getDecimalPoint());
114        buffer.reset();
115
116        assertTrue(DoubleConversion.fixedDtoa(999999999999999868928.00, 2, buffer));
117        assertEquals("999999999999999868928", buffer.getRawDigits());
118        assertEquals(21, buffer.getDecimalPoint());
119        buffer.reset();
120
121        assertTrue(DoubleConversion.fixedDtoa(6.9999999999999989514240000e+21, 5, buffer));
122        assertEquals("6999999999999998951424", buffer.getRawDigits());
123        assertEquals(22, buffer.getDecimalPoint());
124        buffer.reset();
125
126        assertTrue(DoubleConversion.fixedDtoa(1.5, 5, buffer));
127        assertEquals("15", buffer.getRawDigits());
128        assertEquals(1, buffer.getDecimalPoint());
129        buffer.reset();
130
131        assertTrue(DoubleConversion.fixedDtoa(1.55, 5, buffer));
132        assertEquals("155", buffer.getRawDigits());
133        assertEquals(1, buffer.getDecimalPoint());
134        buffer.reset();
135
136        assertTrue(DoubleConversion.fixedDtoa(1.55, 1, buffer));
137        assertEquals("16", buffer.getRawDigits());
138        assertEquals(1, buffer.getDecimalPoint());
139        buffer.reset();
140
141        assertTrue(DoubleConversion.fixedDtoa(1.00000001, 15, buffer));
142        assertEquals("100000001", buffer.getRawDigits());
143        assertEquals(1, buffer.getDecimalPoint());
144        buffer.reset();
145
146        assertTrue(DoubleConversion.fixedDtoa(0.1, 10, buffer));
147        assertEquals("1", buffer.getRawDigits());
148        assertEquals(0, buffer.getDecimalPoint());
149        buffer.reset();
150
151        assertTrue(DoubleConversion.fixedDtoa(0.01, 10, buffer));
152        assertEquals("1", buffer.getRawDigits());
153        assertEquals(-1, buffer.getDecimalPoint());
154        buffer.reset();
155
156        assertTrue(DoubleConversion.fixedDtoa(0.001, 10, buffer));
157        assertEquals("1", buffer.getRawDigits());
158        assertEquals(-2, buffer.getDecimalPoint());
159        buffer.reset();
160
161        assertTrue(DoubleConversion.fixedDtoa(0.0001, 10, buffer));
162        assertEquals("1", buffer.getRawDigits());
163        assertEquals(-3, buffer.getDecimalPoint());
164        buffer.reset();
165
166        assertTrue(DoubleConversion.fixedDtoa(0.00001, 10, buffer));
167        assertEquals("1", buffer.getRawDigits());
168        assertEquals(-4, buffer.getDecimalPoint());
169        buffer.reset();
170
171        assertTrue(DoubleConversion.fixedDtoa(0.000001, 10, buffer));
172        assertEquals("1", buffer.getRawDigits());
173        assertEquals(-5, buffer.getDecimalPoint());
174        buffer.reset();
175
176        assertTrue(DoubleConversion.fixedDtoa(0.0000001, 10, buffer));
177        assertEquals("1", buffer.getRawDigits());
178        assertEquals(-6, buffer.getDecimalPoint());
179        buffer.reset();
180
181        assertTrue(DoubleConversion.fixedDtoa(0.00000001, 10, buffer));
182        assertEquals("1", buffer.getRawDigits());
183        assertEquals(-7, buffer.getDecimalPoint());
184        buffer.reset();
185
186        assertTrue(DoubleConversion.fixedDtoa(0.000000001, 10, buffer));
187        assertEquals("1", buffer.getRawDigits());
188        assertEquals(-8, buffer.getDecimalPoint());
189        buffer.reset();
190
191        assertTrue(DoubleConversion.fixedDtoa(0.0000000001, 15, buffer));
192        assertEquals("1", buffer.getRawDigits());
193        assertEquals(-9, buffer.getDecimalPoint());
194        buffer.reset();
195
196        assertTrue(DoubleConversion.fixedDtoa(0.00000000001, 15, buffer));
197        assertEquals("1", buffer.getRawDigits());
198        assertEquals(-10, buffer.getDecimalPoint());
199        buffer.reset();
200
201        assertTrue(DoubleConversion.fixedDtoa(0.000000000001, 15, buffer));
202        assertEquals("1", buffer.getRawDigits());
203        assertEquals(-11, buffer.getDecimalPoint());
204        buffer.reset();
205
206        assertTrue(DoubleConversion.fixedDtoa(0.0000000000001, 15, buffer));
207        assertEquals("1", buffer.getRawDigits());
208        assertEquals(-12, buffer.getDecimalPoint());
209        buffer.reset();
210
211        assertTrue(DoubleConversion.fixedDtoa(0.00000000000001, 15, buffer));
212        assertEquals("1", buffer.getRawDigits());
213        assertEquals(-13, buffer.getDecimalPoint());
214        buffer.reset();
215
216        assertTrue(DoubleConversion.fixedDtoa(0.000000000000001, 20, buffer));
217        assertEquals("1", buffer.getRawDigits());
218        assertEquals(-14, buffer.getDecimalPoint());
219        buffer.reset();
220
221        assertTrue(DoubleConversion.fixedDtoa(0.0000000000000001, 20, buffer));
222        assertEquals("1", buffer.getRawDigits());
223        assertEquals(-15, buffer.getDecimalPoint());
224        buffer.reset();
225
226        assertTrue(DoubleConversion.fixedDtoa(0.00000000000000001, 20, buffer));
227        assertEquals("1", buffer.getRawDigits());
228        assertEquals(-16, buffer.getDecimalPoint());
229        buffer.reset();
230
231        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000001, 20, buffer));
232        assertEquals("1", buffer.getRawDigits());
233        assertEquals(-17, buffer.getDecimalPoint());
234        buffer.reset();
235
236        assertTrue(DoubleConversion.fixedDtoa(0.0000000000000000001, 20, buffer));
237        assertEquals("1", buffer.getRawDigits());
238        assertEquals(-18, buffer.getDecimalPoint());
239        buffer.reset();
240
241        assertTrue(DoubleConversion.fixedDtoa(0.00000000000000000001, 20, buffer));
242        assertEquals("1", buffer.getRawDigits());
243        assertEquals(-19, buffer.getDecimalPoint());
244        buffer.reset();
245
246        assertTrue(DoubleConversion.fixedDtoa(0.10000000004, 10, buffer));
247        assertEquals("1", buffer.getRawDigits());
248        assertEquals(0, buffer.getDecimalPoint());
249        buffer.reset();
250
251        assertTrue(DoubleConversion.fixedDtoa(0.01000000004, 10, buffer));
252        assertEquals("1", buffer.getRawDigits());
253        assertEquals(-1, buffer.getDecimalPoint());
254        buffer.reset();
255
256        assertTrue(DoubleConversion.fixedDtoa(0.00100000004, 10, buffer));
257        assertEquals("1", buffer.getRawDigits());
258        assertEquals(-2, buffer.getDecimalPoint());
259        buffer.reset();
260
261        assertTrue(DoubleConversion.fixedDtoa(0.00010000004, 10, buffer));
262        assertEquals("1", buffer.getRawDigits());
263        assertEquals(-3, buffer.getDecimalPoint());
264        buffer.reset();
265
266        assertTrue(DoubleConversion.fixedDtoa(0.00001000004, 10, buffer));
267        assertEquals("1", buffer.getRawDigits());
268        assertEquals(-4, buffer.getDecimalPoint());
269        buffer.reset();
270
271        assertTrue(DoubleConversion.fixedDtoa(0.00000100004, 10, buffer));
272        assertEquals("1", buffer.getRawDigits());
273        assertEquals(-5, buffer.getDecimalPoint());
274        buffer.reset();
275
276        assertTrue(DoubleConversion.fixedDtoa(0.00000010004, 10, buffer));
277        assertEquals("1", buffer.getRawDigits());
278        assertEquals(-6, buffer.getDecimalPoint());
279        buffer.reset();
280
281        assertTrue(DoubleConversion.fixedDtoa(0.00000001004, 10, buffer));
282        assertEquals("1", buffer.getRawDigits());
283        assertEquals(-7, buffer.getDecimalPoint());
284        buffer.reset();
285
286        assertTrue(DoubleConversion.fixedDtoa(0.00000000104, 10, buffer));
287        assertEquals("1", buffer.getRawDigits());
288        assertEquals(-8, buffer.getDecimalPoint());
289        buffer.reset();
290
291        assertTrue(DoubleConversion.fixedDtoa(0.0000000001000004, 15, buffer));
292        assertEquals("1", buffer.getRawDigits());
293        assertEquals(-9, buffer.getDecimalPoint());
294        buffer.reset();
295
296        assertTrue(DoubleConversion.fixedDtoa(0.0000000000100004, 15, buffer));
297        assertEquals("1", buffer.getRawDigits());
298        assertEquals(-10, buffer.getDecimalPoint());
299        buffer.reset();
300
301        assertTrue(DoubleConversion.fixedDtoa(0.0000000000010004, 15, buffer));
302        assertEquals("1", buffer.getRawDigits());
303        assertEquals(-11, buffer.getDecimalPoint());
304        buffer.reset();
305
306        assertTrue(DoubleConversion.fixedDtoa(0.0000000000001004, 15, buffer));
307        assertEquals("1", buffer.getRawDigits());
308        assertEquals(-12, buffer.getDecimalPoint());
309        buffer.reset();
310
311        assertTrue(DoubleConversion.fixedDtoa(0.0000000000000104, 15, buffer));
312        assertEquals("1", buffer.getRawDigits());
313        assertEquals(-13, buffer.getDecimalPoint());
314        buffer.reset();
315
316        assertTrue(DoubleConversion.fixedDtoa(0.000000000000001000004, 20, buffer));
317        assertEquals("1", buffer.getRawDigits());
318        assertEquals(-14, buffer.getDecimalPoint());
319        buffer.reset();
320
321        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000100004, 20, buffer));
322        assertEquals("1", buffer.getRawDigits());
323        assertEquals(-15, buffer.getDecimalPoint());
324        buffer.reset();
325
326        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000010004, 20, buffer));
327        assertEquals("1", buffer.getRawDigits());
328        assertEquals(-16, buffer.getDecimalPoint());
329        buffer.reset();
330
331        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000001004, 20, buffer));
332        assertEquals("1", buffer.getRawDigits());
333        assertEquals(-17, buffer.getDecimalPoint());
334        buffer.reset();
335
336        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000104, 20, buffer));
337        assertEquals("1", buffer.getRawDigits());
338        assertEquals(-18, buffer.getDecimalPoint());
339        buffer.reset();
340
341        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000014, 20, buffer));
342        assertEquals("1", buffer.getRawDigits());
343        assertEquals(-19, buffer.getDecimalPoint());
344        buffer.reset();
345
346        assertTrue(DoubleConversion.fixedDtoa(0.10000000006, 10, buffer));
347        assertEquals("1000000001", buffer.getRawDigits());
348        assertEquals(0, buffer.getDecimalPoint());
349        buffer.reset();
350
351        assertTrue(DoubleConversion.fixedDtoa(0.01000000006, 10, buffer));
352        assertEquals("100000001", buffer.getRawDigits());
353        assertEquals(-1, buffer.getDecimalPoint());
354        buffer.reset();
355
356        assertTrue(DoubleConversion.fixedDtoa(0.00100000006, 10, buffer));
357        assertEquals("10000001", buffer.getRawDigits());
358        assertEquals(-2, buffer.getDecimalPoint());
359        buffer.reset();
360
361        assertTrue(DoubleConversion.fixedDtoa(0.00010000006, 10, buffer));
362        assertEquals("1000001", buffer.getRawDigits());
363        assertEquals(-3, buffer.getDecimalPoint());
364        buffer.reset();
365
366        assertTrue(DoubleConversion.fixedDtoa(0.00001000006, 10, buffer));
367        assertEquals("100001", buffer.getRawDigits());
368        assertEquals(-4, buffer.getDecimalPoint());
369        buffer.reset();
370
371        assertTrue(DoubleConversion.fixedDtoa(0.00000100006, 10, buffer));
372        assertEquals("10001", buffer.getRawDigits());
373        assertEquals(-5, buffer.getDecimalPoint());
374        buffer.reset();
375
376        assertTrue(DoubleConversion.fixedDtoa(0.00000010006, 10, buffer));
377        assertEquals("1001", buffer.getRawDigits());
378        assertEquals(-6, buffer.getDecimalPoint());
379        buffer.reset();
380
381        assertTrue(DoubleConversion.fixedDtoa(0.00000001006, 10, buffer));
382        assertEquals("101", buffer.getRawDigits());
383        assertEquals(-7, buffer.getDecimalPoint());
384        buffer.reset();
385
386        assertTrue(DoubleConversion.fixedDtoa(0.00000000106, 10, buffer));
387        assertEquals("11", buffer.getRawDigits());
388        assertEquals(-8, buffer.getDecimalPoint());
389        buffer.reset();
390
391        assertTrue(DoubleConversion.fixedDtoa(0.0000000001000006, 15, buffer));
392        assertEquals("100001", buffer.getRawDigits());
393        assertEquals(-9, buffer.getDecimalPoint());
394        buffer.reset();
395
396        assertTrue(DoubleConversion.fixedDtoa(0.0000000000100006, 15, buffer));
397        assertEquals("10001", buffer.getRawDigits());
398        assertEquals(-10, buffer.getDecimalPoint());
399        buffer.reset();
400
401        assertTrue(DoubleConversion.fixedDtoa(0.0000000000010006, 15, buffer));
402        assertEquals("1001", buffer.getRawDigits());
403        assertEquals(-11, buffer.getDecimalPoint());
404        buffer.reset();
405
406        assertTrue(DoubleConversion.fixedDtoa(0.0000000000001006, 15, buffer));
407        assertEquals("101", buffer.getRawDigits());
408        assertEquals(-12, buffer.getDecimalPoint());
409        buffer.reset();
410
411        assertTrue(DoubleConversion.fixedDtoa(0.0000000000000106, 15, buffer));
412        assertEquals("11", buffer.getRawDigits());
413        assertEquals(-13, buffer.getDecimalPoint());
414        buffer.reset();
415
416        assertTrue(DoubleConversion.fixedDtoa(0.000000000000001000006, 20, buffer));
417        assertEquals("100001", buffer.getRawDigits());
418        assertEquals(-14, buffer.getDecimalPoint());
419        buffer.reset();
420
421        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000100006, 20, buffer));
422        assertEquals("10001", buffer.getRawDigits());
423        assertEquals(-15, buffer.getDecimalPoint());
424        buffer.reset();
425
426        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000010006, 20, buffer));
427        assertEquals("1001", buffer.getRawDigits());
428        assertEquals(-16, buffer.getDecimalPoint());
429        buffer.reset();
430
431        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000001006, 20, buffer));
432        assertEquals("101", buffer.getRawDigits());
433        assertEquals(-17, buffer.getDecimalPoint());
434        buffer.reset();
435
436        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000106, 20, buffer));
437        assertEquals("11", buffer.getRawDigits());
438        assertEquals(-18, buffer.getDecimalPoint());
439        buffer.reset();
440
441        assertTrue(DoubleConversion.fixedDtoa(0.000000000000000000016, 20, buffer));
442        assertEquals("2", buffer.getRawDigits());
443        assertEquals(-19, buffer.getDecimalPoint());
444        buffer.reset();
445
446        assertTrue(DoubleConversion.fixedDtoa(0.6, 0, buffer));
447        assertEquals("1", buffer.getRawDigits());
448        assertEquals(1, buffer.getDecimalPoint());
449        buffer.reset();
450
451        assertTrue(DoubleConversion.fixedDtoa(0.96, 1, buffer));
452        assertEquals("1", buffer.getRawDigits());
453        assertEquals(1, buffer.getDecimalPoint());
454        buffer.reset();
455
456        assertTrue(DoubleConversion.fixedDtoa(0.996, 2, buffer));
457        assertEquals("1", buffer.getRawDigits());
458        assertEquals(1, buffer.getDecimalPoint());
459        buffer.reset();
460
461        assertTrue(DoubleConversion.fixedDtoa(0.9996, 3, buffer));
462        assertEquals("1", buffer.getRawDigits());
463        assertEquals(1, buffer.getDecimalPoint());
464        buffer.reset();
465
466        assertTrue(DoubleConversion.fixedDtoa(0.99996, 4, buffer));
467        assertEquals("1", buffer.getRawDigits());
468        assertEquals(1, buffer.getDecimalPoint());
469        buffer.reset();
470
471        assertTrue(DoubleConversion.fixedDtoa(0.999996, 5, buffer));
472        assertEquals("1", buffer.getRawDigits());
473        assertEquals(1, buffer.getDecimalPoint());
474        buffer.reset();
475
476        assertTrue(DoubleConversion.fixedDtoa(0.9999996, 6, buffer));
477        assertEquals("1", buffer.getRawDigits());
478        assertEquals(1, buffer.getDecimalPoint());
479        buffer.reset();
480
481        assertTrue(DoubleConversion.fixedDtoa(0.99999996, 7, buffer));
482        assertEquals("1", buffer.getRawDigits());
483        assertEquals(1, buffer.getDecimalPoint());
484        buffer.reset();
485
486        assertTrue(DoubleConversion.fixedDtoa(0.999999996, 8, buffer));
487        assertEquals("1", buffer.getRawDigits());
488        assertEquals(1, buffer.getDecimalPoint());
489        buffer.reset();
490
491        assertTrue(DoubleConversion.fixedDtoa(0.9999999996, 9, buffer));
492        assertEquals("1", buffer.getRawDigits());
493        assertEquals(1, buffer.getDecimalPoint());
494        buffer.reset();
495
496        assertTrue(DoubleConversion.fixedDtoa(0.99999999996, 10, buffer));
497        assertEquals("1", buffer.getRawDigits());
498        assertEquals(1, buffer.getDecimalPoint());
499        buffer.reset();
500
501        assertTrue(DoubleConversion.fixedDtoa(0.999999999996, 11, buffer));
502        assertEquals("1", buffer.getRawDigits());
503        assertEquals(1, buffer.getDecimalPoint());
504        buffer.reset();
505
506        assertTrue(DoubleConversion.fixedDtoa(0.9999999999996, 12, buffer));
507        assertEquals("1", buffer.getRawDigits());
508        assertEquals(1, buffer.getDecimalPoint());
509        buffer.reset();
510
511        assertTrue(DoubleConversion.fixedDtoa(0.99999999999996, 13, buffer));
512        assertEquals("1", buffer.getRawDigits());
513        assertEquals(1, buffer.getDecimalPoint());
514        buffer.reset();
515
516        assertTrue(DoubleConversion.fixedDtoa(0.999999999999996, 14, buffer));
517        assertEquals("1", buffer.getRawDigits());
518        assertEquals(1, buffer.getDecimalPoint());
519        buffer.reset();
520
521        assertTrue(DoubleConversion.fixedDtoa(0.9999999999999996, 15, buffer));
522        assertEquals("1", buffer.getRawDigits());
523        assertEquals(1, buffer.getDecimalPoint());
524        buffer.reset();
525
526        assertTrue(DoubleConversion.fixedDtoa(0.00999999999999996, 16, buffer));
527        assertEquals("1", buffer.getRawDigits());
528        assertEquals(-1, buffer.getDecimalPoint());
529        buffer.reset();
530
531        assertTrue(DoubleConversion.fixedDtoa(0.000999999999999996, 17, buffer));
532        assertEquals("1", buffer.getRawDigits());
533        assertEquals(-2, buffer.getDecimalPoint());
534        buffer.reset();
535
536        assertTrue(DoubleConversion.fixedDtoa(0.0000999999999999996, 18, buffer));
537        assertEquals("1", buffer.getRawDigits());
538        assertEquals(-3, buffer.getDecimalPoint());
539        buffer.reset();
540
541        assertTrue(DoubleConversion.fixedDtoa(0.00000999999999999996, 19, buffer));
542        assertEquals("1", buffer.getRawDigits());
543        assertEquals(-4, buffer.getDecimalPoint());
544        buffer.reset();
545
546        assertTrue(DoubleConversion.fixedDtoa(0.000000999999999999996, 20, buffer));
547        assertEquals("1", buffer.getRawDigits());
548        assertEquals(-5, buffer.getDecimalPoint());
549        buffer.reset();
550
551        assertTrue(DoubleConversion.fixedDtoa(323423.234234, 10, buffer));
552        assertEquals("323423234234", buffer.getRawDigits());
553        assertEquals(6, buffer.getDecimalPoint());
554        buffer.reset();
555
556        assertTrue(DoubleConversion.fixedDtoa(12345678.901234, 4, buffer));
557        assertEquals("123456789012", buffer.getRawDigits());
558        assertEquals(8, buffer.getDecimalPoint());
559        buffer.reset();
560
561        assertTrue(DoubleConversion.fixedDtoa(98765.432109, 5, buffer));
562        assertEquals("9876543211", buffer.getRawDigits());
563        assertEquals(5, buffer.getDecimalPoint());
564        buffer.reset();
565
566        assertTrue(DoubleConversion.fixedDtoa(42, 20, buffer));
567        assertEquals("42", buffer.getRawDigits());
568        assertEquals(2, buffer.getDecimalPoint());
569        buffer.reset();
570
571        assertTrue(DoubleConversion.fixedDtoa(0.5, 0, buffer));
572        assertEquals("1", buffer.getRawDigits());
573        assertEquals(1, buffer.getDecimalPoint());
574        buffer.reset();
575
576        assertTrue(DoubleConversion.fixedDtoa(1e-23, 10, buffer));
577        assertEquals("", buffer.getRawDigits());
578        assertEquals(-10, buffer.getDecimalPoint());
579        buffer.reset();
580
581        assertTrue(DoubleConversion.fixedDtoa(1e-123, 2, buffer));
582        assertEquals("", buffer.getRawDigits());
583        assertEquals(-2, buffer.getDecimalPoint());
584        buffer.reset();
585
586        assertTrue(DoubleConversion.fixedDtoa(1e-123, 0, buffer));
587        assertEquals("", buffer.getRawDigits());
588        assertEquals(0, buffer.getDecimalPoint());
589        buffer.reset();
590
591        assertTrue(DoubleConversion.fixedDtoa(1e-23, 20, buffer));
592        assertEquals("", buffer.getRawDigits());
593        assertEquals(-20, buffer.getDecimalPoint());
594        buffer.reset();
595
596        assertTrue(DoubleConversion.fixedDtoa(1e-21, 20, buffer));
597        assertEquals("", buffer.getRawDigits());
598        assertEquals(-20, buffer.getDecimalPoint());
599        buffer.reset();
600
601        assertTrue(DoubleConversion.fixedDtoa(1e-22, 20, buffer));
602        assertEquals("", buffer.getRawDigits());
603        assertEquals(-20, buffer.getDecimalPoint());
604        buffer.reset();
605
606        assertTrue(DoubleConversion.fixedDtoa(6e-21, 20, buffer));
607        assertEquals("1", buffer.getRawDigits());
608        assertEquals(-19, buffer.getDecimalPoint());
609        buffer.reset();
610
611        assertTrue(DoubleConversion.fixedDtoa(9.1193616301674545152000000e+19, 0, buffer));
612        assertEquals("91193616301674545152", buffer.getRawDigits());
613        assertEquals(20, buffer.getDecimalPoint());
614        buffer.reset();
615
616        assertTrue(DoubleConversion.fixedDtoa(4.8184662102767651659096515e-04, 19, buffer));
617        assertEquals("4818466210276765", buffer.getRawDigits());
618        assertEquals(-3, buffer.getDecimalPoint());
619        buffer.reset();
620
621        assertTrue(DoubleConversion.fixedDtoa(1.9023164229540652612705182e-23, 8, buffer));
622        assertEquals("", buffer.getRawDigits());
623        assertEquals(-8, buffer.getDecimalPoint());
624        buffer.reset();
625
626        assertTrue(DoubleConversion.fixedDtoa(1000000000000000128.0, 0, buffer));
627        assertEquals("1000000000000000128", buffer.getRawDigits());
628        assertEquals(19, buffer.getDecimalPoint());
629        buffer.reset();
630    }
631
632
633
634    @Test
635    public void testFastFixed() {
636        final AtomicInteger total = new AtomicInteger();
637        final AtomicInteger succeeded = new AtomicInteger();
638
639        new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("resources/gay-fixed.txt")))
640                .lines()
641                .forEach(line -> {
642                    if (line.isEmpty() || line.startsWith("//")) {
643                        return; // comment or empty line
644                    }
645                    final String[] tokens = line.split(",\\s+");
646                    assertEquals(tokens.length, 4);
647                    final double v = Double.parseDouble(tokens[0]);
648                    final int digits = Integer.parseInt(tokens[1]);
649                    final String str = tokens[2].replace('"', ' ').trim();;
650                    final int point = Integer.parseInt(tokens[3]);
651                    final DtoaBuffer buffer = new DtoaBuffer(kBufferSize);
652                    total.getAndIncrement();
653
654                    if (DoubleConversion.fixedDtoa(v, digits, buffer)) {
655                        assertEquals(str, buffer.getRawDigits());
656                        assertEquals(point, buffer.getDecimalPoint());
657                        succeeded.getAndIncrement();
658                    }
659                });
660
661        // should work for all numbers
662        assertEquals(succeeded.get(), total.get());
663    }
664
665}
666