1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.primitives;
18
19 import static com.google.common.truth.Truth.assertThat;
20 import static java.lang.Float.NaN;
21
22 import com.google.common.annotations.GwtCompatible;
23 import com.google.common.annotations.GwtIncompatible;
24 import com.google.common.base.Converter;
25 import com.google.common.collect.ImmutableList;
26 import com.google.common.collect.testing.Helpers;
27 import com.google.common.testing.NullPointerTester;
28 import com.google.common.testing.SerializableTester;
29
30 import junit.framework.TestCase;
31
32 import java.util.Arrays;
33 import java.util.Collection;
34 import java.util.Collections;
35 import java.util.Comparator;
36 import java.util.List;
37
38
39
40
41
42
43 @GwtCompatible(emulated = true)
44 @SuppressWarnings("cast")
45 public class FloatsTest extends TestCase {
46 private static final float[] EMPTY = {};
47 private static final float[] ARRAY1 = {(float) 1};
48 private static final float[] ARRAY234
49 = {(float) 2, (float) 3, (float) 4};
50
51 private static final float LEAST = Float.NEGATIVE_INFINITY;
52 private static final float GREATEST = Float.POSITIVE_INFINITY;
53
54 private static final float[] NUMBERS = new float[] {
55 LEAST, -Float.MAX_VALUE, -1f, -0f, 0f, 1f, Float.MAX_VALUE, GREATEST,
56 Float.MIN_NORMAL, -Float.MIN_NORMAL, Float.MIN_VALUE, -Float.MIN_VALUE,
57 Integer.MIN_VALUE, Integer.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE
58 };
59
60 private static final float[] VALUES
61 = Floats.concat(NUMBERS, new float[] {NaN});
62
63 public void testHashCode() {
64 for (float value : VALUES) {
65 assertEquals(((Float) value).hashCode(), Floats.hashCode(value));
66 }
67 }
68
69 public void testIsFinite() {
70 for (float value : NUMBERS) {
71 assertEquals(!(Float.isInfinite(value) || Float.isNaN(value)), Floats.isFinite(value));
72 }
73 }
74
75 public void testCompare() {
76 for (float x : VALUES) {
77 for (float y : VALUES) {
78
79 assertEquals(x + ", " + y,
80 Float.valueOf(x).compareTo(y),
81 Floats.compare(x, y));
82 }
83 }
84 }
85
86 public void testContains() {
87 assertFalse(Floats.contains(EMPTY, (float) 1));
88 assertFalse(Floats.contains(ARRAY1, (float) 2));
89 assertFalse(Floats.contains(ARRAY234, (float) 1));
90 assertTrue(Floats.contains(new float[] {(float) -1}, (float) -1));
91 assertTrue(Floats.contains(ARRAY234, (float) 2));
92 assertTrue(Floats.contains(ARRAY234, (float) 3));
93 assertTrue(Floats.contains(ARRAY234, (float) 4));
94
95 for (float value : NUMBERS) {
96 assertTrue("" + value, Floats.contains(new float[] {5f, value}, value));
97 }
98 assertFalse(Floats.contains(new float[] {5f, NaN}, NaN));
99 }
100
101 public void testIndexOf() {
102 assertEquals(-1, Floats.indexOf(EMPTY, (float) 1));
103 assertEquals(-1, Floats.indexOf(ARRAY1, (float) 2));
104 assertEquals(-1, Floats.indexOf(ARRAY234, (float) 1));
105 assertEquals(0, Floats.indexOf(
106 new float[] {(float) -1}, (float) -1));
107 assertEquals(0, Floats.indexOf(ARRAY234, (float) 2));
108 assertEquals(1, Floats.indexOf(ARRAY234, (float) 3));
109 assertEquals(2, Floats.indexOf(ARRAY234, (float) 4));
110 assertEquals(1, Floats.indexOf(
111 new float[] { (float) 2, (float) 3, (float) 2, (float) 3 },
112 (float) 3));
113
114 for (float value : NUMBERS) {
115 assertEquals("" + value, 1,
116 Floats.indexOf(new float[] {5f, value}, value));
117 }
118 assertEquals(-1, Floats.indexOf(new float[] {5f, NaN}, NaN));
119 }
120
121 public void testIndexOf_arrayTarget() {
122 assertEquals(0, Floats.indexOf(EMPTY, EMPTY));
123 assertEquals(0, Floats.indexOf(ARRAY234, EMPTY));
124 assertEquals(-1, Floats.indexOf(EMPTY, ARRAY234));
125 assertEquals(-1, Floats.indexOf(ARRAY234, ARRAY1));
126 assertEquals(-1, Floats.indexOf(ARRAY1, ARRAY234));
127 assertEquals(0, Floats.indexOf(ARRAY1, ARRAY1));
128 assertEquals(0, Floats.indexOf(ARRAY234, ARRAY234));
129 assertEquals(0, Floats.indexOf(
130 ARRAY234, new float[] { (float) 2, (float) 3 }));
131 assertEquals(1, Floats.indexOf(
132 ARRAY234, new float[] { (float) 3, (float) 4 }));
133 assertEquals(1, Floats.indexOf(ARRAY234, new float[] { (float) 3 }));
134 assertEquals(2, Floats.indexOf(ARRAY234, new float[] { (float) 4 }));
135 assertEquals(1, Floats.indexOf(new float[] { (float) 2, (float) 3,
136 (float) 3, (float) 3, (float) 3 },
137 new float[] { (float) 3 }
138 ));
139 assertEquals(2, Floats.indexOf(
140 new float[] { (float) 2, (float) 3, (float) 2,
141 (float) 3, (float) 4, (float) 2, (float) 3},
142 new float[] { (float) 2, (float) 3, (float) 4}
143 ));
144 assertEquals(1, Floats.indexOf(
145 new float[] { (float) 2, (float) 2, (float) 3,
146 (float) 4, (float) 2, (float) 3, (float) 4},
147 new float[] { (float) 2, (float) 3, (float) 4}
148 ));
149 assertEquals(-1, Floats.indexOf(
150 new float[] { (float) 4, (float) 3, (float) 2},
151 new float[] { (float) 2, (float) 3, (float) 4}
152 ));
153
154 for (float value : NUMBERS) {
155 assertEquals("" + value, 1, Floats.indexOf(
156 new float[] {5f, value, value, 5f}, new float[] {value, value}));
157 }
158 assertEquals(-1, Floats.indexOf(
159 new float[] {5f, NaN, NaN, 5f}, new float[] {NaN, NaN}));
160 }
161
162 public void testLastIndexOf() {
163 assertEquals(-1, Floats.lastIndexOf(EMPTY, (float) 1));
164 assertEquals(-1, Floats.lastIndexOf(ARRAY1, (float) 2));
165 assertEquals(-1, Floats.lastIndexOf(ARRAY234, (float) 1));
166 assertEquals(0, Floats.lastIndexOf(
167 new float[] {(float) -1}, (float) -1));
168 assertEquals(0, Floats.lastIndexOf(ARRAY234, (float) 2));
169 assertEquals(1, Floats.lastIndexOf(ARRAY234, (float) 3));
170 assertEquals(2, Floats.lastIndexOf(ARRAY234, (float) 4));
171 assertEquals(3, Floats.lastIndexOf(
172 new float[] { (float) 2, (float) 3, (float) 2, (float) 3 },
173 (float) 3));
174
175 for (float value : NUMBERS) {
176 assertEquals("" + value,
177 0, Floats.lastIndexOf(new float[] {value, 5f}, value));
178 }
179 assertEquals(-1, Floats.lastIndexOf(new float[] {NaN, 5f}, NaN));
180 }
181
182 public void testMax_noArgs() {
183 try {
184 Floats.max();
185 fail();
186 } catch (IllegalArgumentException expected) {
187 }
188 }
189
190 public void testMax() {
191 assertEquals(GREATEST, Floats.max(GREATEST));
192 assertEquals(LEAST, Floats.max(LEAST));
193 assertEquals((float) 9, Floats.max(
194 (float) 8, (float) 6, (float) 7,
195 (float) 5, (float) 3, (float) 0, (float) 9));
196
197 assertEquals(0f, Floats.max(-0f, 0f));
198 assertEquals(0f, Floats.max(0f, -0f));
199 assertEquals(GREATEST, Floats.max(NUMBERS));
200 assertTrue(Float.isNaN(Floats.max(VALUES)));
201 }
202
203 public void testMin_noArgs() {
204 try {
205 Floats.min();
206 fail();
207 } catch (IllegalArgumentException expected) {
208 }
209 }
210
211 public void testMin() {
212 assertEquals(LEAST, Floats.min(LEAST));
213 assertEquals(GREATEST, Floats.min(GREATEST));
214 assertEquals((float) 0, Floats.min(
215 (float) 8, (float) 6, (float) 7,
216 (float) 5, (float) 3, (float) 0, (float) 9));
217
218 assertEquals(-0f, Floats.min(-0f, 0f));
219 assertEquals(-0f, Floats.min(0f, -0f));
220 assertEquals(LEAST, Floats.min(NUMBERS));
221 assertTrue(Float.isNaN(Floats.min(VALUES)));
222 }
223
224 public void testConcat() {
225 assertTrue(Arrays.equals(EMPTY, Floats.concat()));
226 assertTrue(Arrays.equals(EMPTY, Floats.concat(EMPTY)));
227 assertTrue(Arrays.equals(EMPTY, Floats.concat(EMPTY, EMPTY, EMPTY)));
228 assertTrue(Arrays.equals(ARRAY1, Floats.concat(ARRAY1)));
229 assertNotSame(ARRAY1, Floats.concat(ARRAY1));
230 assertTrue(Arrays.equals(ARRAY1, Floats.concat(EMPTY, ARRAY1, EMPTY)));
231 assertTrue(Arrays.equals(
232 new float[] {(float) 1, (float) 1, (float) 1},
233 Floats.concat(ARRAY1, ARRAY1, ARRAY1)));
234 assertTrue(Arrays.equals(
235 new float[] {(float) 1, (float) 2, (float) 3, (float) 4},
236 Floats.concat(ARRAY1, ARRAY234)));
237 }
238
239 public void testEnsureCapacity() {
240 assertSame(EMPTY, Floats.ensureCapacity(EMPTY, 0, 1));
241 assertSame(ARRAY1, Floats.ensureCapacity(ARRAY1, 0, 1));
242 assertSame(ARRAY1, Floats.ensureCapacity(ARRAY1, 1, 1));
243 assertTrue(Arrays.equals(
244 new float[] {(float) 1, (float) 0, (float) 0},
245 Floats.ensureCapacity(ARRAY1, 2, 1)));
246 }
247
248 public void testEnsureCapacity_fail() {
249 try {
250 Floats.ensureCapacity(ARRAY1, -1, 1);
251 fail();
252 } catch (IllegalArgumentException expected) {
253 }
254 try {
255
256 Floats.ensureCapacity(ARRAY1, 1, -1);
257 fail();
258 } catch (IllegalArgumentException expected) {
259 }
260 }
261
262 @GwtIncompatible("Float.toString returns different value in GWT.")
263 public void testJoin() {
264 assertEquals("", Floats.join(",", EMPTY));
265 assertEquals("1.0", Floats.join(",", ARRAY1));
266 assertEquals("1.0,2.0", Floats.join(",", (float) 1, (float) 2));
267 assertEquals("1.02.03.0",
268 Floats.join("", (float) 1, (float) 2, (float) 3));
269 }
270
271 public void testLexicographicalComparator() {
272 List<float[]> ordered = Arrays.asList(
273 new float[] {},
274 new float[] {LEAST},
275 new float[] {LEAST, LEAST},
276 new float[] {LEAST, (float) 1},
277 new float[] {(float) 1},
278 new float[] {(float) 1, LEAST},
279 new float[] {GREATEST, Float.MAX_VALUE},
280 new float[] {GREATEST, GREATEST},
281 new float[] {GREATEST, GREATEST, GREATEST});
282
283 Comparator<float[]> comparator = Floats.lexicographicalComparator();
284 Helpers.testComparator(comparator, ordered);
285 }
286
287 @GwtIncompatible("SerializableTester")
288 public void testLexicographicalComparatorSerializable() {
289 Comparator<float[]> comparator = Floats.lexicographicalComparator();
290 assertSame(comparator, SerializableTester.reserialize(comparator));
291 }
292
293 @GwtIncompatible("SerializableTester")
294 public void testStringConverterSerialization() {
295 SerializableTester.reserializeAndAssert(Floats.stringConverter());
296 }
297
298 public void testToArray() {
299
300 List<Float> none = Arrays.<Float>asList();
301 assertTrue(Arrays.equals(EMPTY, Floats.toArray(none)));
302
303 List<Float> one = Arrays.asList((float) 1);
304 assertTrue(Arrays.equals(ARRAY1, Floats.toArray(one)));
305
306 float[] array = {(float) 0, (float) 1, (float) 3};
307
308 List<Float> three = Arrays.asList((float) 0, (float) 1, (float) 3);
309 assertTrue(Arrays.equals(array, Floats.toArray(three)));
310
311 assertTrue(Arrays.equals(array, Floats.toArray(Floats.asList(array))));
312 }
313
314 public void testToArray_threadSafe() {
315 for (int delta : new int[] { +1, 0, -1 }) {
316 for (int i = 0; i < VALUES.length; i++) {
317 List<Float> list = Floats.asList(VALUES).subList(0, i);
318 Collection<Float> misleadingSize =
319 Helpers.misleadingSizeCollection(delta);
320 misleadingSize.addAll(list);
321 float[] arr = Floats.toArray(misleadingSize);
322 assertEquals(i, arr.length);
323 for (int j = 0; j < i; j++) {
324 assertEquals(VALUES[j], arr[j]);
325 }
326 }
327 }
328 }
329
330 public void testToArray_withNull() {
331 List<Float> list = Arrays.asList((float) 0, (float) 1, null);
332 try {
333 Floats.toArray(list);
334 fail();
335 } catch (NullPointerException expected) {
336 }
337 }
338
339 public void testToArray_withConversion() {
340 float[] array = {(float) 0, (float) 1, (float) 2};
341
342 List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
343 List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);
344 List<Integer> ints = Arrays.asList(0, 1, 2);
345 List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2);
346 List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
347 List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);
348
349 assertTrue(Arrays.equals(array, Floats.toArray(bytes)));
350 assertTrue(Arrays.equals(array, Floats.toArray(shorts)));
351 assertTrue(Arrays.equals(array, Floats.toArray(ints)));
352 assertTrue(Arrays.equals(array, Floats.toArray(floats)));
353 assertTrue(Arrays.equals(array, Floats.toArray(longs)));
354 assertTrue(Arrays.equals(array, Floats.toArray(doubles)));
355 }
356
357 public void testAsList_isAView() {
358 float[] array = {(float) 0, (float) 1};
359 List<Float> list = Floats.asList(array);
360 list.set(0, (float) 2);
361 assertTrue(Arrays.equals(new float[] {(float) 2, (float) 1}, array));
362 array[1] = (float) 3;
363 assertThat(list).has().exactly((float) 2, (float) 3).inOrder();
364 }
365
366 public void testAsList_toArray_roundTrip() {
367 float[] array = { (float) 0, (float) 1, (float) 2 };
368 List<Float> list = Floats.asList(array);
369 float[] newArray = Floats.toArray(list);
370
371
372 list.set(0, (float) 4);
373 assertTrue(Arrays.equals(
374 new float[] { (float) 0, (float) 1, (float) 2 }, newArray));
375 newArray[1] = (float) 5;
376 assertEquals((float) 1, (float) list.get(1));
377 }
378
379
380 public void testAsList_subList_toArray_roundTrip() {
381 float[] array = { (float) 0, (float) 1, (float) 2, (float) 3 };
382 List<Float> list = Floats.asList(array);
383 assertTrue(Arrays.equals(new float[] { (float) 1, (float) 2 },
384 Floats.toArray(list.subList(1, 3))));
385 assertTrue(Arrays.equals(new float[] {},
386 Floats.toArray(list.subList(2, 2))));
387 }
388
389 public void testAsListEmpty() {
390 assertSame(Collections.emptyList(), Floats.asList(EMPTY));
391 }
392
393
394
395
396
397 private static Float referenceTryParse(String input) {
398 if (input.trim().length() < input.length()) {
399 return null;
400 }
401 try {
402 return Float.valueOf(input);
403 } catch (NumberFormatException e) {
404 return null;
405 }
406 }
407
408 @GwtIncompatible("Floats.tryParse")
409 private static void checkTryParse(String input) {
410 assertEquals(referenceTryParse(input), Floats.tryParse(input));
411 }
412
413 @GwtIncompatible("Floats.tryParse")
414 private static void checkTryParse(float expected, String input) {
415 assertEquals(Float.valueOf(expected), Floats.tryParse(input));
416 }
417
418 @GwtIncompatible("Floats.tryParse")
419 public void testTryParseHex() {
420 for (String signChar : ImmutableList.of("", "+", "-")) {
421 for (String hexPrefix : ImmutableList.of("0x", "0X")) {
422 for (String iPart : ImmutableList.of("", "0", "1", "F", "f", "c4", "CE")) {
423 for (String fPart : ImmutableList.of("", ".", ".F", ".52", ".a")) {
424 for (String expMarker : ImmutableList.of("p", "P")) {
425 for (String exponent : ImmutableList.of("0", "-5", "+20", "52")) {
426 for (String typePart : ImmutableList.of("", "D", "F", "d", "f")) {
427 checkTryParse(
428 signChar + hexPrefix + iPart + fPart + expMarker + exponent + typePart);
429 }
430 }
431 }
432 }
433 }
434 }
435 }
436 }
437
438 @GwtIncompatible("Floats.tryParse")
439 public void testTryParseAllCodePoints() {
440
441 char[] tmp = new char[2];
442 for (int i = Character.MIN_CODE_POINT; i < Character.MAX_CODE_POINT; i++) {
443 Character.toChars(i, tmp, 0);
444 checkTryParse(String.copyValueOf(tmp, 0, Character.charCount(i)));
445 }
446 }
447
448 @GwtIncompatible("Floats.tryParse")
449 public void testTryParseOfToStringIsOriginal() {
450 for (float f : NUMBERS) {
451 checkTryParse(f, Float.toString(f));
452 }
453 }
454
455 @GwtIncompatible("Floats.tryParse")
456 public void testTryParseOfToHexStringIsOriginal() {
457 for (float f : NUMBERS) {
458 checkTryParse(f, Float.toHexString(f));
459 }
460 }
461
462 @GwtIncompatible("Floats.tryParse")
463 public void testTryParseNaN() {
464 checkTryParse("NaN");
465 checkTryParse("+NaN");
466 checkTryParse("-NaN");
467 }
468
469 @GwtIncompatible("Floats.tryParse")
470 public void testTryParseInfinity() {
471 checkTryParse(Float.POSITIVE_INFINITY, "Infinity");
472 checkTryParse(Float.POSITIVE_INFINITY, "+Infinity");
473 checkTryParse(Float.NEGATIVE_INFINITY, "-Infinity");
474 }
475
476 private static final String[] BAD_TRY_PARSE_INPUTS =
477 { "", "+-", "+-0", " 5", "32 ", " 55 ", "infinity", "POSITIVE_INFINITY", "0x9A", "0x9A.bE-5",
478 ".", ".e5", "NaNd", "InfinityF" };
479
480 @GwtIncompatible("Floats.tryParse")
481 public void testTryParseFailures() {
482 for (String badInput : BAD_TRY_PARSE_INPUTS) {
483 assertEquals(referenceTryParse(badInput), Floats.tryParse(badInput));
484 assertNull(Floats.tryParse(badInput));
485 }
486 }
487
488 @GwtIncompatible("NullPointerTester")
489 public void testNulls() {
490 new NullPointerTester().testAllPublicStaticMethods(Floats.class);
491 }
492
493 @GwtIncompatible("Float.toString returns different value in GWT.")
494 public void testStringConverter_convert() {
495 Converter<String, Float> converter = Floats.stringConverter();
496 assertEquals((Float) 1.0f, converter.convert("1.0"));
497 assertEquals((Float) 0.0f, converter.convert("0.0"));
498 assertEquals((Float) (-1.0f), converter.convert("-1.0"));
499 assertEquals((Float) 1.0f, converter.convert("1"));
500 assertEquals((Float) 0.0f, converter.convert("0"));
501 assertEquals((Float) (-1.0f), converter.convert("-1"));
502 assertEquals((Float) 1e6f, converter.convert("1e6"));
503 assertEquals((Float) 1e-6f, converter.convert("1e-6"));
504 }
505
506 public void testStringConverter_convertError() {
507 try {
508 Floats.stringConverter().convert("notanumber");
509 fail();
510 } catch (NumberFormatException expected) {
511 }
512 }
513
514 public void testStringConverter_nullConversions() {
515 assertNull(Floats.stringConverter().convert(null));
516 assertNull(Floats.stringConverter().reverse().convert(null));
517 }
518
519 @GwtIncompatible("Float.toString returns different value in GWT.")
520 public void testStringConverter_reverse() {
521 Converter<String, Float> converter = Floats.stringConverter();
522 assertEquals("1.0", converter.reverse().convert(1.0f));
523 assertEquals("0.0", converter.reverse().convert(0.0f));
524 assertEquals("-1.0", converter.reverse().convert(-1.0f));
525 assertEquals("1000000.0", converter.reverse().convert(1e6f));
526 assertEquals("1.0E-6", converter.reverse().convert(1e-6f));
527 }
528
529 @GwtIncompatible("NullPointerTester")
530 public void testStringConverter_nullPointerTester() throws Exception {
531 NullPointerTester tester = new NullPointerTester();
532 tester.testAllPublicInstanceMethods(Floats.stringConverter());
533 }
534 }