1 /* 2 * Copyright (c) 1999, 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. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @library .. 27 * @bug 4103117 4331084 4488017 4490929 6255285 6268365 8074460 28 * @summary Tests the BigDecimal string constructor (use -Dseed=X to set PRNG seed). 29 */ 30 31 import java.math.*; 32 33 public class StringConstructor { 34 35 private static RandomSeed rndSeed = new RandomSeed(false); 36 37 public static void main(String[] args) throws Exception { 38 System.out.println("Random number generator seed = " + rndSeed.getSeed()); 39 40 constructWithError(""); 41 constructWithError("+"); 42 constructWithError("-"); 43 constructWithError("+e"); 44 constructWithError("-e"); 45 constructWithError("e+"); 46 constructWithError("1.-0"); 47 constructWithError(".-123"); 48 constructWithError("-"); 49 constructWithError("--1.1"); 50 constructWithError("-+1.1"); 51 constructWithError("+-1.1"); 52 constructWithError("1-.1"); 53 constructWithError("1+.1"); 54 constructWithError("1.111+1"); 55 constructWithError("1.111-1"); 56 constructWithError("11.e+"); 57 constructWithError("11.e-"); 58 constructWithError("11.e+-"); 59 constructWithError("11.e-+"); 60 constructWithError("11.e-+1"); 61 constructWithError("11.e+-1"); 62 63 // Range checks 64 constructWithError("1e"+Integer.MIN_VALUE); 65 constructWithError("10e"+Integer.MIN_VALUE); 66 constructWithError("0.01e"+Integer.MIN_VALUE); 67 constructWithError("1e"+((long)Integer.MIN_VALUE-1)); 68 constructWithError("1e"+((long)Integer.MAX_VALUE + 1)); 69 70 leadingExponentZeroTest(); 71 nonAsciiZeroTest(); 72 73 // Roundtrip tests 74 for (int i=0; i<100; i++) { 75 int size = rndSeed.getRandom().nextInt(100) + 1; 76 BigInteger bi = new BigInteger(size, rndSeed.getRandom()); 77 if (rndSeed.getRandom().nextBoolean()) 78 bi = bi.negate(); 79 int decimalLength = bi.toString().length(); 80 int scale = rndSeed.getRandom().nextInt(decimalLength); 81 BigDecimal bd = new BigDecimal(bi, scale); 82 String bdString = bd.toString(); 83 // System.err.println("bi" + bi.toString() + "\tscale " + scale); 84 // System.err.println("bd string: " + bdString); 85 BigDecimal bdDoppel = new BigDecimal(bdString); 86 if (!bd.equals(bdDoppel)) { 87 System.err.println("bd string: scale: " + bd.scale() + 88 "\t" + bdString); 89 System.err.println("bd doppel: scale: " + bdDoppel.scale() + 90 "\t" + bdDoppel.toString()); 91 throw new RuntimeException("String constructor failure."); 92 } 93 } 94 } 95 96 97 /* 98 * Verify precision is set properly if the significand has 99 * non-ASCII leading zeros. 100 */ 101 private static void nonAsciiZeroTest() { 102 String values[] = { 103 "00004e5", 104 "\u0660\u0660\u0660\u06604e5", 105 }; 106 107 BigDecimal expected = new BigDecimal("4e5"); 108 109 for(String s : values) { 110 BigDecimal tmp = new BigDecimal(s); 111 // System.err.println("Testing " + s); 112 if (! expected.equals(tmp) || tmp.precision() != 1) { 113 System.err.println("Bad conversion of " + s + "got " + 114 tmp + "precision = " + tmp.precision()); 115 throw new RuntimeException("String constructor failure."); 116 } 117 } 118 119 } 120 121 private static void leadingExponentZeroTest() { 122 BigDecimal twelve = new BigDecimal("12"); 123 BigDecimal onePointTwo = new BigDecimal("1.2"); 124 125 String start = "1.2e0"; 126 String end = "1"; 127 String middle = ""; 128 129 // Test with more excess zeros than the largest number of 130 // decimal digits needed to represent a long 131 int limit = ((int)Math.log10(Long.MAX_VALUE)) + 6; 132 for(int i = 0; i < limit; i++, middle += "0") { 133 String t1 = start + middle; 134 String t2 = t1 + end; 135 136 // System.out.println(i + "\t" + t1 + "\t" + t2); 137 testString(t1, onePointTwo); 138 testString(t2, twelve); 139 } 140 } 141 142 private static void testString(String s, BigDecimal expected) { 143 testString0(s, expected); 144 testString0(switchZero(s), expected); 145 } 146 147 private static void testString0(String s, BigDecimal expected) { 148 if (!expected.equals(new BigDecimal(s))) 149 throw new RuntimeException(s + " is not equal to " + expected); 150 } 151 152 private static String switchZero(String s) { 153 return s.replace('0', '\u0660'); // Arabic-Indic zero 154 } 155 156 private static void constructWithError(String badString) { 157 try { 158 BigDecimal d = new BigDecimal(badString); 159 throw new RuntimeException(badString + " accepted"); 160 } catch(NumberFormatException e) { 161 } 162 } 163 }