1 /*
2 * Copyright (c) 2012, 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 import org.testng.annotations.DataProvider;
25 import org.testng.annotations.Test;
26
27 import java.math.BigInteger;
28 import java.util.ArrayList;
29 import java.util.Iterator;
30 import java.util.Arrays;
31 import java.util.List;
32 import java.util.function.LongFunction;
33 import java.util.function.Function;
34
35 import static org.testng.Assert.assertEquals;
36
37 /**
38 * @test
39 * @run testng IntegralPrimitiveToString
40 * @summary test string conversions for primitive integral types.
41 * @author Mike Duigou
42 */
43 public class IntegralPrimitiveToString {
44
45 @Test(dataProvider="numbers")
46 public <N extends Number> void testToString(String description,
47 Function<N, BigInteger> converter,
48 Function<N, BigInteger> unsignedConverter,
49 N[] values,
50 Stringifier<N>[] stringifiers) {
51 System.out.printf("%s : conversions: %d values: %d\n", description, stringifiers.length, values.length);
52 for( N value : values) {
53 BigInteger asBigInt = converter.apply(value);
54 BigInteger asUnsignedBigInt = unsignedConverter.apply(value);
55 for(Stringifier<N> stringifier : stringifiers) {
56 stringifier.assertMatchingToString(value, asBigInt, asUnsignedBigInt, description);
57 }
58 }
59 }
60
61 static class Stringifier<N extends Number> {
62 final boolean signed;
63 final int radix;
64 final Function<N,String> toString;
65 Stringifier(boolean signed, int radix, Function<N,String> toString) {
66 this.signed = signed;
67 this.radix = radix;
68 this.toString = toString;
69 }
70
71 public void assertMatchingToString(N value, BigInteger asSigned, BigInteger asUnsigned, String description) {
72 String expected = signed
73 ? asSigned.toString(radix)
74 : asUnsigned.toString(radix);
75
76 String actual = toString.apply(value);
77
78 assertEquals(actual, expected, description + " conversion should be the same");
79 }
80 }
81
82 @DataProvider(name="numbers", parallel=true)
83 public Iterator<Object[]> testSetProvider() {
84
85 return Arrays.asList(
86 new Object[] { "Byte",
87 (Function<Byte,BigInteger>) b -> BigInteger.valueOf((long) b),
88 (Function<Byte,BigInteger>) b -> BigInteger.valueOf(Integer.toUnsignedLong((byte) b)),
89 numberProvider((LongFunction<Byte>) l -> Byte.valueOf((byte) l), Byte.SIZE),
90 new Stringifier[] {
91 new Stringifier<Byte>(true, 10, b -> b.toString()),
92 new Stringifier<Byte>(true, 10, b -> Byte.toString(b))
93 }
94 },
95 new Object[] { "Short",
96 (Function<Short,BigInteger>) s -> BigInteger.valueOf((long) s),
97 (Function<Short,BigInteger>) s -> BigInteger.valueOf(Integer.toUnsignedLong((short) s)),
98 numberProvider((LongFunction<Short>) l -> Short.valueOf((short) l), Short.SIZE),
99 new Stringifier[] {
100 new Stringifier<Short>(true, 10, s -> s.toString()),
101 new Stringifier<Short>(true, 10, s -> Short.toString( s))
102 }
103 },
104 new Object[] { "Integer",
105 (Function<Integer,BigInteger>) i -> BigInteger.valueOf((long) i),
106 (Function<Integer,BigInteger>) i -> BigInteger.valueOf(Integer.toUnsignedLong(i)),
107 numberProvider((LongFunction<Integer>) l -> Integer.valueOf((int) l), Integer.SIZE),
108 new Stringifier[] {
109 new Stringifier<Integer>(true, 10, i -> i.toString()),
110 new Stringifier<Integer>(true, 10, i -> Integer.toString(i)),
111 new Stringifier<Integer>(false, 2, Integer::toBinaryString),
112 new Stringifier<Integer>(false, 16, Integer::toHexString),
113 new Stringifier<Integer>(false, 8, Integer::toOctalString),
114 new Stringifier<Integer>(true, 2, i -> Integer.toString(i, 2)),
115 new Stringifier<Integer>(true, 8, i -> Integer.toString(i, 8)),
116 new Stringifier<Integer>(true, 10, i -> Integer.toString(i, 10)),
117 new Stringifier<Integer>(true, 16, i -> Integer.toString(i, 16)),
118 new Stringifier<Integer>(true, Character.MAX_RADIX, i -> Integer.toString(i, Character.MAX_RADIX)),
119 new Stringifier<Integer>(false, 10, i -> Integer.toUnsignedString(i)),
120 new Stringifier<Integer>(false, 2, i -> Integer.toUnsignedString(i, 2)),
121 new Stringifier<Integer>(false, 8, i -> Integer.toUnsignedString(i, 8)),
122 new Stringifier<Integer>(false, 10, i -> Integer.toUnsignedString(i, 10)),
123 new Stringifier<Integer>(false, 16, i -> Integer.toUnsignedString(i, 16)),
124 new Stringifier<Integer>(false, Character.MAX_RADIX, i -> Integer.toUnsignedString(i, Character.MAX_RADIX))
125 }
126 },
127 new Object[] { "Long",
128 (Function<Long, BigInteger>) BigInteger::valueOf,
129 (Function<Long, BigInteger>) l -> {
130 if (l >= 0) {
131 return BigInteger.valueOf((long) l);
132 } else {
133 int upper = (int)(l >>> 32);
134 int lower = (int) (long) l;
135
136 // return (upper << 32) + lower
137 return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
138 add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
139 }
140 },
141 numberProvider((LongFunction<Long>) Long::valueOf, Long.SIZE),
142 new Stringifier[] {
143 new Stringifier<Long>(true, 10, l -> l.toString()),
144 new Stringifier<Long>(true, 10, l -> Long.toString(l)),
145 new Stringifier<Long>(false, 2, Long::toBinaryString),
146 new Stringifier<Long>(false, 16, Long::toHexString),
147 new Stringifier<Long>(false, 8, Long::toOctalString),
148 new Stringifier<Long>(true, 2, l -> Long.toString(l, 2)),
149 new Stringifier<Long>(true, 8, l -> Long.toString(l, 8)),
150 new Stringifier<Long>(true, 10, l -> Long.toString(l, 10)),
151 new Stringifier<Long>(true, 16, l -> Long.toString(l, 16)),
152 new Stringifier<Long>(true, Character.MAX_RADIX, l -> Long.toString(l, Character.MAX_RADIX)),
153 new Stringifier<Long>(false, 10, Long::toUnsignedString),
154 new Stringifier<Long>(false, 2, l -> Long.toUnsignedString(l, 2)),
155 new Stringifier<Long>(false, 8, l-> Long.toUnsignedString(l, 8)),
156 new Stringifier<Long>(false, 10, l -> Long.toUnsignedString(l, 10)),
157 new Stringifier<Long>(false, 16, l -> Long.toUnsignedString(l, 16)),
158 new Stringifier<Long>(false, Character.MAX_RADIX, l -> Long.toUnsignedString(l, Character.MAX_RADIX))
159 }
160 }
161 ).iterator();
162 }
163 private static final long[] SOME_PRIMES = {
164 3L, 5L, 7L, 11L, 13L, 17L, 19L, 23L, 29L, 31L, 37L, 41L, 43L, 47L, 53L,
165 59L, 61L, 71L, 73L, 79L, 83L, 89L, 97L, 101L, 103L, 107L, 109L, 113L,
166 5953L, 5981L, 5987L, 6007L, 6011L, 6029L, 6037L, 6043L, 6047L, 6053L,
167 16369L, 16381L, 16411L, 32749L, 32771L, 65521L, 65537L,
168 (long) Integer.MAX_VALUE };
169
170 public <N extends Number> N[] numberProvider(LongFunction<N> boxer, int bits, N... extras) {
171 List<N> numbers = new ArrayList<>();
172
173 for(int bitmag = 0; bitmag < bits; bitmag++) {
174 long value = 1L << bitmag;
175 numbers.add(boxer.apply(value));
176 numbers.add(boxer.apply(value - 1));
177 numbers.add(boxer.apply(value + 1));
178 numbers.add(boxer.apply(-value));
179 for(int divisor = 0; divisor < SOME_PRIMES.length && value < SOME_PRIMES[divisor]; divisor++) {
180 numbers.add(boxer.apply(value - SOME_PRIMES[divisor]));
181 numbers.add(boxer.apply(value + SOME_PRIMES[divisor]));
182 numbers.add(boxer.apply(value * SOME_PRIMES[divisor]));
183 numbers.add(boxer.apply(value / SOME_PRIMES[divisor]));
184 numbers.add(boxer.apply(value | SOME_PRIMES[divisor]));
185 numbers.add(boxer.apply(value & SOME_PRIMES[divisor]));
186 numbers.add(boxer.apply(value ^ SOME_PRIMES[divisor]));
187 }
188 }
189
190 numbers.addAll(Arrays.asList(extras));
191
192 return (N[]) numbers.toArray(new Number[numbers.size()]);
193 }
194 }