FixedDtoaTest.java revision 1511:a1f59730bfb5 
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@SuppressWarnings("javadoc")
75public 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
629
630
631    @Test
632    public void testFastFixed() {
633        final AtomicInteger total = new AtomicInteger();
634        final AtomicInteger succeeded = new AtomicInteger();
635
636        new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("resources/gay-fixed.txt")))
637                .lines()
638                .forEach(line -> {
639                    if (line.isEmpty() || line.startsWith("//")) {
640                        return; // comment or empty line
641                    }
642                    final String[] tokens = line.split(",\\s+");
643                    assertEquals(tokens.length, 4);
644                    final double v = Double.parseDouble(tokens[0]);
645                    final int digits = Integer.parseInt(tokens[1]);
646                    final String str = tokens[2].replace('"', ' ').trim();;
647                    final int point = Integer.parseInt(tokens[3]);
648                    final DtoaBuffer buffer = new DtoaBuffer(kBufferSize);
649                    total.getAndIncrement();
650
651                    if (DoubleConversion.fixedDtoa(v, digits, buffer)) {
652                        assertEquals(str, buffer.getRawDigits());
653                        assertEquals(point, buffer.getDecimalPoint());
654                        succeeded.getAndIncrement();
655                    }
656                });
657
658        // should work for all numbers
659        assertEquals(succeeded.get(), total.get());
660    }
661
662}
663