1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package com.google.common.primitives;
16
17 import com.google.common.annotations.GwtCompatible;
18 import com.google.common.annotations.GwtIncompatible;
19 import com.google.common.collect.ImmutableSet;
20 import com.google.common.testing.EqualsTester;
21 import com.google.common.testing.NullPointerTester;
22 import com.google.common.testing.SerializableTester;
23
24 import junit.framework.TestCase;
25
26 import java.math.BigInteger;
27
28
29
30
31
32
33 @GwtCompatible(emulated = true)
34 public class UnsignedLongTest extends TestCase {
35 private static final ImmutableSet<Long> TEST_LONGS;
36 private static final ImmutableSet<BigInteger> TEST_BIG_INTEGERS;
37
38 static {
39 ImmutableSet.Builder<Long> testLongsBuilder = ImmutableSet.builder();
40 ImmutableSet.Builder<BigInteger> testBigIntegersBuilder = ImmutableSet.builder();
41 for (long i = -3; i <= 3; i++) {
42 testLongsBuilder
43 .add(i)
44 .add(Long.MAX_VALUE + i)
45 .add(Long.MIN_VALUE + i)
46 .add(Integer.MIN_VALUE + i)
47 .add(Integer.MAX_VALUE + i);
48 BigInteger bigI = BigInteger.valueOf(i);
49 testBigIntegersBuilder
50 .add(bigI)
51 .add(BigInteger.valueOf(Long.MAX_VALUE).add(bigI))
52 .add(BigInteger.valueOf(Long.MIN_VALUE).add(bigI))
53 .add(BigInteger.valueOf(Integer.MAX_VALUE).add(bigI))
54 .add(BigInteger.valueOf(Integer.MIN_VALUE).add(bigI))
55 .add(BigInteger.ONE.shiftLeft(63).add(bigI))
56 .add(BigInteger.ONE.shiftLeft(64).add(bigI));
57 }
58 TEST_LONGS = testLongsBuilder.build();
59 TEST_BIG_INTEGERS = testBigIntegersBuilder.build();
60 }
61
62 public void testAsUnsignedAndLongValueAreInverses() {
63 for (long value : TEST_LONGS) {
64 assertEquals(
65 UnsignedLongs.toString(value), value, UnsignedLong.fromLongBits(value).longValue());
66 }
67 }
68
69 public void testAsUnsignedBigIntegerValue() {
70 for (long value : TEST_LONGS) {
71 BigInteger expected = (value >= 0)
72 ? BigInteger.valueOf(value)
73 : BigInteger.valueOf(value).add(BigInteger.ZERO.setBit(64));
74 assertEquals(UnsignedLongs.toString(value), expected,
75 UnsignedLong.fromLongBits(value).bigIntegerValue());
76 }
77 }
78
79 public void testValueOfLong() {
80 for (long value : TEST_LONGS) {
81 boolean expectSuccess = value >= 0;
82 try {
83 assertEquals(value, UnsignedLong.valueOf(value).longValue());
84 assertTrue(expectSuccess);
85 } catch (IllegalArgumentException e) {
86 assertFalse(expectSuccess);
87 }
88 }
89 }
90
91 public void testValueOfBigInteger() {
92 BigInteger min = BigInteger.ZERO;
93 BigInteger max = UnsignedLong.MAX_VALUE.bigIntegerValue();
94 for (BigInteger big : TEST_BIG_INTEGERS) {
95 boolean expectSuccess =
96 big.compareTo(min) >= 0 && big.compareTo(max) <= 0;
97 try {
98 assertEquals(big, UnsignedLong.valueOf(big).bigIntegerValue());
99 assertTrue(expectSuccess);
100 } catch (IllegalArgumentException e) {
101 assertFalse(expectSuccess);
102 }
103 }
104 }
105
106 public void testToString() {
107 for (long value : TEST_LONGS) {
108 UnsignedLong unsignedValue = UnsignedLong.fromLongBits(value);
109 assertEquals(unsignedValue.bigIntegerValue().toString(), unsignedValue.toString());
110 }
111 }
112
113 @GwtIncompatible("too slow")
114 public void testToStringRadix() {
115 for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) {
116 for (long l : TEST_LONGS) {
117 UnsignedLong value = UnsignedLong.fromLongBits(l);
118 assertEquals(value.bigIntegerValue().toString(radix), value.toString(radix));
119 }
120 }
121 }
122
123 public void testToStringRadixQuick() {
124 int[] radices = {2, 3, 5, 7, 10, 12, 16, 21, 31, 36};
125 for (int radix : radices) {
126 for (long l : TEST_LONGS) {
127 UnsignedLong value = UnsignedLong.fromLongBits(l);
128 assertEquals(value.bigIntegerValue().toString(radix), value.toString(radix));
129 }
130 }
131 }
132
133 public void testFloatValue() {
134 for (long value : TEST_LONGS) {
135 UnsignedLong unsignedValue = UnsignedLong.fromLongBits(value);
136 assertEquals(unsignedValue.bigIntegerValue().floatValue(), unsignedValue.floatValue());
137 }
138 }
139
140 public void testDoubleValue() {
141 for (long value : TEST_LONGS) {
142 UnsignedLong unsignedValue = UnsignedLong.fromLongBits(value);
143 assertEquals(unsignedValue.bigIntegerValue().doubleValue(), unsignedValue.doubleValue());
144 }
145 }
146
147 public void testPlus() {
148 for (long a : TEST_LONGS) {
149 for (long b : TEST_LONGS) {
150 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
151 UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
152 long expected = aUnsigned
153 .bigIntegerValue()
154 .add(bUnsigned.bigIntegerValue())
155 .longValue();
156 UnsignedLong unsignedSum = aUnsigned.plus(bUnsigned);
157 assertEquals(expected, unsignedSum.longValue());
158 }
159 }
160 }
161
162 public void testMinus() {
163 for (long a : TEST_LONGS) {
164 for (long b : TEST_LONGS) {
165 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
166 UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
167 long expected = aUnsigned
168 .bigIntegerValue()
169 .subtract(bUnsigned.bigIntegerValue())
170 .longValue();
171 UnsignedLong unsignedSub = aUnsigned.minus(bUnsigned);
172 assertEquals(expected, unsignedSub.longValue());
173 }
174 }
175 }
176
177 public void testTimes() {
178 for (long a : TEST_LONGS) {
179 for (long b : TEST_LONGS) {
180 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
181 UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
182 long expected = aUnsigned
183 .bigIntegerValue()
184 .multiply(bUnsigned.bigIntegerValue())
185 .longValue();
186 UnsignedLong unsignedMul = aUnsigned.times(bUnsigned);
187 assertEquals(expected, unsignedMul.longValue());
188 }
189 }
190 }
191
192 public void testDividedBy() {
193 for (long a : TEST_LONGS) {
194 for (long b : TEST_LONGS) {
195 if (b != 0) {
196 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
197 UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
198 long expected = aUnsigned
199 .bigIntegerValue()
200 .divide(bUnsigned.bigIntegerValue())
201 .longValue();
202 UnsignedLong unsignedDiv = aUnsigned.dividedBy(bUnsigned);
203 assertEquals(expected, unsignedDiv.longValue());
204 }
205 }
206 }
207 }
208
209 @SuppressWarnings("ReturnValueIgnored")
210 public void testDivideByZeroThrows() {
211 for (long a : TEST_LONGS) {
212 try {
213 UnsignedLong.fromLongBits(a).dividedBy(UnsignedLong.ZERO);
214 fail("Expected ArithmeticException");
215 } catch (ArithmeticException expected) {}
216 }
217 }
218
219 public void testMod() {
220 for (long a : TEST_LONGS) {
221 for (long b : TEST_LONGS) {
222 if (b != 0) {
223 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
224 UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
225 long expected = aUnsigned
226 .bigIntegerValue()
227 .remainder(bUnsigned.bigIntegerValue())
228 .longValue();
229 UnsignedLong unsignedRem = aUnsigned.mod(bUnsigned);
230 assertEquals(expected, unsignedRem.longValue());
231 }
232 }
233 }
234 }
235
236 @SuppressWarnings("ReturnValueIgnored")
237 public void testModByZero() {
238 for (long a : TEST_LONGS) {
239 try {
240 UnsignedLong.fromLongBits(a).mod(UnsignedLong.ZERO);
241 fail("Expected ArithmeticException");
242 } catch (ArithmeticException expected) {}
243 }
244 }
245
246 public void testCompare() {
247 for (long a : TEST_LONGS) {
248 for (long b : TEST_LONGS) {
249 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
250 UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
251 assertEquals(aUnsigned.bigIntegerValue().compareTo(bUnsigned.bigIntegerValue()),
252 aUnsigned.compareTo(bUnsigned));
253 }
254 }
255 }
256
257 @GwtIncompatible("too slow")
258 public void testEquals() {
259 EqualsTester equalsTester = new EqualsTester();
260 for (long a : TEST_LONGS) {
261 BigInteger big =
262 (a >= 0) ? BigInteger.valueOf(a) : BigInteger.valueOf(a).add(BigInteger.ZERO.setBit(64));
263 equalsTester.addEqualityGroup(UnsignedLong.fromLongBits(a), UnsignedLong.valueOf(big),
264 UnsignedLong.valueOf(big.toString()), UnsignedLong.valueOf(big.toString(16), 16));
265 }
266 equalsTester.testEquals();
267 }
268
269 public void testIntValue() {
270 for (long a : TEST_LONGS) {
271 UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
272 int intValue = aUnsigned.bigIntegerValue().intValue();
273 assertEquals(intValue, aUnsigned.intValue());
274 }
275 }
276
277 @GwtIncompatible("serialization")
278 public void testSerialization() {
279 for (long a : TEST_LONGS) {
280 SerializableTester.reserializeAndAssert(UnsignedLong.fromLongBits(a));
281 }
282 }
283
284 @GwtIncompatible("NullPointerTester")
285 public void testNulls() {
286 new NullPointerTester().testAllPublicStaticMethods(UnsignedLong.class);
287 }
288 }